¿Por Qué Go?

¿Qué es Go o Golang?
Go es un lenguaje de programación de alto nivel, compilado y multiplataforma, creado por tres programadores de Google, Robert
Griesemer, Rob Pike y Ken Thompson con la idea de que sea un lenguaje de programación optimizado y más sencillo.
Un proyecto modesto se convirtió en un ambicioso propósito cuyo desarrollo fue impulsado por Google, que dispuso todos los recursos
necesarios para el desarrollo.
La primera versión de Go se publicó en 2012, desde ese momento su crecimiento en la comunidad no para de aumentar.
La sintaxis de Go tiene mucha semejanza a la del lenguaje C, el propósito de este lenguaje de programación es que sea, tan rápido como
C y tan sencillo de leer y escribir como Python. Golang o Go es un lenguaje compilado y esto hace que sea más efectiva. El lenguaje
también cuenta con un recolector de basura automático o nativa (Garbage Collector o GC), que aporta a gestionar con eficiencia el
manejo de memoria.
¿Por qué Go?
 Velocidad similar a C pero con una sintaxis amigable como Python.

 Facilita el uso de buenas prácticas en el código.
 Mantiene su rendimiento con grandes volúmenes de información.
 Su curva de aprendizaje es suave en comparación con Java o C.
 Es un lenguaje multiparadigma.
 Ahorras tiempo al codear. Por ejemplo, para crear ciclos solo existe la función for.
 Para manejar niveles de accesos de funciones es tan sencillo como colocar la primera letra en mayúscula o minúscula.
Concurrencia
Una de las principales funciones de Golang es que maneja las múltiples tareas de forma concurrente, es decir, que el procesador divide
el trabajo en múltiples hilos y a cada uno le dedica un tiempo en milisegundos acelerando el tiempo de ejecución en cada tarea sin
necesidad de realizar configuraciones adicionales ya que Golang lo traen en sus librerías preinstaladas.
La manera como Golang trabaja esto es a través de Goroutines y Canales. Puedes tener múltiples Goroutines por canal y transportar el
Goroutine de un canal a otro. Un excelente uso de Goroutines es al momento de trabajar transferencia de datos en tiempo real desde un
cliente a otro, como por ejemplo un chat o un sistema de ubicación en tiempo real.
¿Para qué se usa Go?
Go es un lenguaje que es más utilizado en el desarrollo web backend, por manejar tareas pesas y aplicar la concurrencia. Go se utiliza el
los siguientes campos.
 Desarrollo web (en lado del servidor)

 Desarrollo de aplicaciones empresariales multiplataforma
 Desarrollo de servicios y microservicios
 Desarrollo de Scripts para el sistema
 Desarrollo de automatizaciones para Devops
 Desarrollar programas en la red
Ejemplo de Go
package main
import "fmt"
func main() {
fmt.Println("Hola Mundo")
}
Lenguaje del código: Go (go)
Instalar Go
Para empezar a codificar con Go se nesesita dos cosas
 Un editor de código o de texto como VS Code, para escribir codigo en Go o tambien IDE.
 Un compilador para compilar el codigo de Go a codigo maquina para ejecutar en la computadora
En la pagina oficial de Go(Golang), podemos encontrar la herramienta de desarrollo de Go el cual trae todas las
herramietas nesesarias para construir nuestra aplicación como tambien el compilador.
Instalar Go en Windows
Para instalar Go descargar el archivo de instalación de la página https://golang.org/dl/ y tambien puedes seguir la
guia de la instalación desde la pagina oficial de Golang https://golang.org/doc/install para diferentes sistemas
operativos.
En el siguiente video tutorial aprenderas a instalar Go, VS Code y configurar tu espacio de trabajo con Go.
Configuración de Variables de Entorno en Windows
 GOROOT: En este variable de entorno va la ruta de la instalación C:\Program Files\Go

 PATH: En este variable de entorno va la ruta de la instalación pero la ruta de la carpeta bin C:\Program
Files\Go\bin
 GOPATH: En este variable de entorno va la ruta de tu espacio de trabajo por Ejemplo C:\User\roel1\
go
 GOBIN: En este variable de entorno va la ruta de la carpeta bin que tienes que tener o crear dentro de tu
espacio de trabajo, por ejemplo. C:\User\roel1\go\bin
Estructura de espacio de trabajo de GO

 BIN: Guarda todo los ejecutables que utilicemos o creemos.
 PKG: Guarda paquetes o librerias que vas a utilizar en tu proyecto
 SRC: Aqui vas crear todo tu codigo o tus proyectos y tambien la librerias que vas a utilizar de terceros.
C:\User\roel1\go\
.bin
.pkg
.src
Lenguaje del código: Bash (bash)
Instalar Go en Linux
Para instalar Go descargar el archivo de instalación de la página https://golang.org/dl/ y tambien puedes seguir la
guia de la instalación desde la pagina oficial de Golang https://golang.org/doc/install para diferentes sistemas
operativos.
Descargar el archivo para linux luego realiza la instalación con indica en la pagina, para darle permiso como
administrado usa sudo.
sudo tar -C /usr/local -xzf go1.16.7.linux-amd64.tar.gz

Lenguaje del código: Basic (basic)
En el siguiente video tutorial aprenderas a instalar Go, VS Code y configurar tu espacio de trabajo con Go en
Linux.
Configuiración de Variables de entorno en Linux
Abre el archivo oculto en la dirección de usuario que es .bashrc abre con algun editor y configura los siguientes
variables de entorno al final de archivo.
export GOROOT=/usr/local/go
export PATH=$PATH:/usr/local/go/bin
export GOPATH=/home/alexroel/workspace/go
export GOBIN=$GOPATH/bin
Intalar Go en Mac
Descargar Go: Para descargar Go se derige a la página oficial de Golang https://golang.org/dl/ y escoje para
sistema operatico mac.
Instalar Go: Cuando termine de descargar puede pasas a inatalar ejecutando el archivo descargado, luego nex o
continue y install.
Una vez descargado el paquete, debes abrirlo y luedo de seguir los pasos del asistente instalarás Go en tu mac
que por defecto se instalará en la siguiente ruta /usr/local/go
Si todo ha salido bien, al abrir una terminal y ejecutar go version debería imprimirte en consola la versión de
Go que acabas de instalar.
Espacio de Trabajo en Mac
 Una vez tengas instalado Go, el paso siguiente es crear la carpeta go, preferiblemente en tu $HOME.
 Una vez creada, debes igualmente crear dentro de ella las siguientes tres carpetas: pkg, src y bin.
Variables de entorno en Mac
Para finalizar, el paso siguiente es crear las variables de entorno. Esto dependerá mucho de cuál Shell estés
utilizando. En el curso estaremos usando Bash Shell, en este caso abrimos el archivo ~/.bash_profile y allí
escribimos lo siguiente al final del archivo:
export GOPATH=$HOME/go
export GOBIN=$GOPATH/bin
export PATH=$PATH:$GOBIN
Aqui tenies mas guias para variables entorno https://github.com/golang/go/wiki/SettingGOPATH

EJEMPLO DE “Hola Mundo en Go”
Para crear un hola mundo en Go podemos crear un archivo con extención con .go por ejemplo hola.go
 Primero tenemos que definir el paquete main que no permitirá ejecutar el archivo
 Para mostrar datos por pantalla o consola importar el paquete fmt
 Para ejecutar nuestro código se tiene que definir la función main y dentro de esta función va todo los
códigos que vas a ejecutar.
 Para mostrar un Hola mundo usamos el paquete fmt y su método Println como se muestra en el siguiente
ejemplo.
package main
import "fmt"
func main() {
}
Para ejecutar este archivo con Go, podemos usar los comando go run nombre_archivo.go el cual compila
internamente y ejecuta y te devuelve le resultado.
go run hola.go
Hola Mundo
Lenguaje del código: Shell Session (shell)
Pero para la produccion tendrias que compilar tu proyecto ya el comando go run esta para modo desarrollo, para
compilar el proyecto se usa el comando go build nombre-archivo.go. esto genera un archivo conpilado que
seria el ejecutable de nuestra aplicación.
Ejeplo de conpilacion en Windows.
C:\Users\roel1\go\src\tutorial-go>go build hola.go
C:\Users\roel1\go\src\tutorial-go>dir
Directorio de C:\Users\roel1\go\src\tutorial-go
30/09/2021 22:17 <DIR> .

30/09/2021 22:17 <DIR> ..
30/09/2021 22:17 1.926.656 hola.exe
30/09/2021 22:06 78 hola.go
2 archivos 1.926.734 bytes
2 dirs 185.063.100.416 bytes libres
Para ejecutar el archivo compilado que en este caso es con extención .exe solo pasas a ejecutar directemante el
erchivo y tendremos el resutaldo de la aplicación.
C:\Users\roel1\go\src\tutorial-go>hola.exe
Hola Mundo
Comentarios en GO
Un comentario es un texto, que es ignorado al momento de ejecutar nuestra aplicación, los comentarios se usas para explicar el código y
hacerlo más legible, estos comentarios también se puedes usar para evitar la ejecución de una línea de código o bloque de código.
Comentarios de una linea en Go
Los comentarios de una sola línea comienzan con dos barras diagonales //, todo texto que este escrito después de estas dos barras
diagonales, el compiladore de Go lo ignora y esto solo sirve para el desarrollador o desarrolladores.
//Esto es un comentario
package main
import "fmt"
func main() {
//Este es otro comentario
}
El siguiente ejemplo muestra como podemos aplicar los comentarios de línea después de una línea de código, y así podemos dejar
alguna explicación corta de esa línea de código.
package main //Paquete principal
import "fmt" // Importar libreria fmt
//Función Principal
func main() {
fmt.Println("Hola Mundo") //Emprime hola mundo
}
Comentarios de Bloque en Go
Los comentarios de bloque o de varias líneas comienza con barra diagonal asterisco /* y terminan con asterisco barra diagonal */,
cualquier texto o código dentro de esta serán ignorados por el compilador.
package main
import "fmt"
func main() {
/* fmt es una libreria de salida y entrada de datos
Println es una función que muestra datos de salida*/
}
En el siguiente ejemplo veremos como poder comentar una línea de código, el cual será ignorado por el compilador.
package main
import "fmt"
func main() {
//fmt.Println("Esta linea no sera ejecutado")
}
Variables en Go
Las variables son contenedores para almacenar valores de diferentes tipos de datos, en Go existen diferentes tipos
de variable. Go es un lenguaje tipado y por eso tenemos que definir variables para cada tipo de dato.
 Iint – almacena numero enteros ya sea positivo o negativo

 Float64 – almacena numero decimales como positivo y negativo
 String – almacena cadena de caracteres y la cadena de caracteres van entre comillas dobles.
 Bool – almacena valore como True y False
Definición de una variable

Las variables se definen con la instrucción var luego el nombre o identificador de la variable y luego el tipo de
dato, la sintaxis seria var identificador tipo = valor. Si el valor de una variable se conoce puedes
asiganar su valor en la linea, y si no se sabe puedes indicar solo el tipo de dato.
package main
import "fmt"
func main() {
var name string = "Alex"
var age int = 26
fmt.Println(name)
fmt.Println(age)
}
Declaración de una variable sin valor inicial
En Go, se inicializan todas las variables. Entonces, si defines unas variables sin valor, su valor se establecerá con
le valor predeterminado de su tipo.
Es importante saber que con Go, los variables no contienen valores nulos u otro tipo de valor, cuando defines una
variable sin inicializar. Por que en Go todas se inicializan automáticamente.
package main
import "fmt"
func main() {
var name string // Valor inicial ""
var age int // Valor inicial 0
var size float64 // Valor iniciar 0
var itsAlive bool // Valor iniciar false
fmt.Println(name)
fmt.Println(age)
fmt.Println(size)
fmt.Println(itsAlive)
}
Asignar valores a una variable después de declarar
Luego de definir las variables podemos asignar otros valores, para modificar el valor inicial.
package main
import "fmt"
func main() {
var name string // Valor inicial ""
var age int // Valor inicial 0
var size float64 // Valor iniciar 0
var itsAlive bool // Valor iniciar false
name = "Alex"
itsAlive = true
fmt.Println(name)
fmt.Println(age)
fmt.Println(size)
}
Definer variables sin tipo de datos

La definición de las variables, podemos simplificar sin indicar el tipo de dato y automáticamente la variable se
convertirá para un tipo de dato de acuerdo a su valor asignado. Para esto si o si tenemos que inicializar
manualmente o agregar ya su valor.
Para eso podemos hacer de dos formas, la primera forma es usando la palabra clave var como se muestra en el
siguiente ejemplo.
package main
import "fmt"
func main() {
var name = "Alex"
var age = 26
fmt.Println(name)
fmt.Println(age)
}
La segunda forma es usado el operador := como se muestra el siguiente ejemplo, este operador solo se usa al
momento de definir, para modificar su valor solo escribes el identificador y el operador igual =.
package main
import "fmt"
func main() {
name := "Alex"
age := 26
name = "Roel"
fmt.Println(name)
fmt.Println(age)
}
Diferencias ente var y :=

 Var – Puedes definir variables fuera y dentro de las funciones, también puedes definir variables sin
asignar un valor indicando el tipo de dato.
 := – Solo puedes definir dentro de la funciones y también tienes que asignar si o si un valor por que no
puedes indicar el tipo de dato.
package main
import "fmt"
var name = "Alex"
func main() {
age := 26
fmt.Println(name)
fmt.Println(age)
}
Definir múltiples variables

Con Go es posible definir múltiples variables de un solo tipo o de varios tipos, asignando u valor o sin asignar un
valor.
Ejemplo de múltiples variables de un solo tipo.
package main
import "fmt"
func main() {
//Sin asignar nigun valor
var a, b, c int
//Asignado un valor
var x, y = 12, 23
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Println(x)
fmt.Println(y)
}
Ejemplo de múltiples variables de diferentes tipos de datos.
package main
import (
"fmt"
)
func main() {
var (
name string = "Alex"
age = 26
size float64
itsAlive bool
)
fmt.Println(name)
fmt.Println(age)
fmt.Println(size)
}
Regla de nombre de variable

 El nombre de una variable debe comenzar con una letra o un carácter de subrayado (_)
 Un nombre de variable no puede comenzar con un dígito o número
 Los nombres de las variables distinguen entre mayúsculas y minúsculas edad, Edad y EDAD son tres
variables diferentes.
 Un nombre de variable no puede contener espacios
 El nombre de la variable no puede ser ninguna palabra clave de Go
Nombre de variable de varias palabras

 Camel Case .- Cada palabra excepto el primero comienza con mayúscula, y esta es mas usa
tradicionalmente en Go para definir la variables. myVariableName
 Pascal Case .- Cada palabra comienza con mayúscula. MyVariableName
 Snake Case .- Cada palabra es separada por barra baja o guion bajo. my_variable_name
Palabras reservadas de Go
break default funct interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var
Constantes en Go
Si una variable debe tener un valor fijo que no se pueda cambiar o modificar, puedes utilizar los constantes. Los
constantes se definen con la palabra clave const. Con esto podemos decir que un constante es inmutable y de
solo lectura.
La sintaxis de como se define una constate es parecida a las variables normales, la diferencia es que en ves de
usar var usas const.
Definición de un constante
 El nombre de los constantes sigue las mismas reglas que las de variables
 De costumbre el nombre de las constantes va de pura mayúscula para diferenciar de las variables.
 Las constantes pueden definirse dentro y fuera de las funciones.
 En Go hay dos tipos de constantes, las escritas y sin tipo de dato.
En el siguiente ejemplo se muestra como se defines las constantes de dos formas, dentro y fuera de la función.
package main
import "fmt"
//Definir un constante
const PI = 3.141592 //Constante sin tipo
func main() {
const A int = 1 //Constante escrita
fmt.Println(PI)
fmt.Println(A)
}
Definición de múltiples constantes

Al igual que con las variables se pueden definir múltiples constantes.
package main
import "fmt"
const (
A = 1
HOLA = "Hola"
C = true
)
func main() {
fmt.Println(A)
fmt.Println(HOLA)
fmt.Println(C)
}
Tipos de Datos en Go
Los tipos de datos son importantes en la programación, el tipo de dato especifica el tamaño y tipo de valor de una
variable. Go es estáticamente tipado, lo que significa que una variable se define para guardar u solo tipo de dato.
Tipos de datos básicos

Los tipos de datos básico que los cuales iniciaremos manipulando primero son:
 Cadena: Representa un valor de cadena de caracteres o texto.

 Numéricos: Representa números enteros y números flotantes.
 Booleanos: Representa un valor booleano de verdadero(true) o falso(false).
package main
import "fmt"
func main() {
var name string = "Alex" // Cadena
var age int = 26 // Número entero
var size float64 = 1.67 //Número flotante
var itsAlive bool = true // Booleano
fmt.Println(name)
fmt.Println(age)
fmt.Println(size)
}
Tipos para números enteros

Para definir las variables con tipo de dato, con numero enteros podemos ser muy específicos, si no le colocamos
un tipo de dato especifico para números enteros, por defecto será de tipo int.
Enteros con signo
Podemos definir variables para que pueda almacenar números positivos o negativos con cantidades limitadas.
 int – 32 o 64 bits
 rune – 32-bits (-2147483648 a 2147483647)
 int8 – 8-bits (-128 a 127)
 int16 – 16-bits (-32768 a 32767)
 int32 – 32-bits (-2147483648 a 2147483647)
 int64 – 64-bits (-9223372036854775808 a 9223372036854775807)
package main
import "fmt"
func main() {
var a int8 = 127 // Rango de -128 a 127
var b rune = 455 // Rango de -2147483648 a 2147483647
fmt.Println(a)
fmt.Println(b)
}
Enteros sin singno
Podemos definir variables que puedan almacenar solo números positivos.
 byte – 8-bits (0 a 255)

 uint – 32 o 64 bits
 uint8 – 8-bits (0 a 255)
 uint16 – 16-bits (0 a 65535)
 uint32 – 32-bits (0 a 4294967295)
 uint64 – 64-bits (0 a 18446744073709551615)
package main
import "fmt"
func main() {
var a byte = 255 // Rango de 0 a 255
var b uint = 455 // Solo positivos
fmt.Println(a)
fmt.Println(b)
}
Tipo para numeros Flotantes y Complejas

Para definir variables para números flotantes tenemos dos y para números grandes y complejas tememos también
dos, puedes definir una variable dependiendo de su rango del valor.
 float32 – 32 bits (-3.4e+38 a 3.4e+38)

 float64 – 64 bist (-1.7e+308 a +1.7e+308)
 complex64
 complex128
package main
import "fmt"
func main() {
var a float32 = 3.56

var b float64 = 1.745468
var c complex64 = 3e+4 // Número complejo
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
}

Salida de Datos en Go
Para la salida de datos, usamos las funciones del paquete fmt, el paquete fmt es amplia, puedes echar un vistazo
la documentación oficial https://pkg.go.dev/fmt.
Para mostrar datos por pantalla o la terminal podemos usar muchas de sus funciones, dependiendo para que lo
necesitemos, los más básicos podemos explorar por ahora es son tres:
 Print() : Imprime datos pero al finalizar no hace un salto a la siguiente línea.

 Println(): Imprime datos y al finalizar hace un salto a la siguiente línea.
 Printf(): Imprime datos formateados al final tampoco hace salto a la siguiente linea.
A estas funciones podemos inviar que nos imprima muchos datos al mismo tiempo, a esto se llama
concatenación, podemos enviar diferentes tipos de datos para que imprima por consola, hasta operaciones
aritméticas o concatenaciones con signo +.
Uso del Print()

Si usamos el print para mostrar datos por pantalla y luego imprimimos varios datos con print, todos los datos
imprimirán en esa misma línea como se muestra en el siguiente ejemplo.
package main
import "fmt"
func main() {
fmt.Print("Hola")
fmt.Print("Mundo")
}
HolaMundo
Concatenacion y Println()
Para imprimir varios datos en la consola en solo print o println podemos concatenar con coma o con signo +,
pero más fácil de hacer ser con coma, ya que te genera automáticamente espacio entre los datos, como se muestra
en el siguiente ejemplo.
package main
import "fmt"
func main() {
var hello, world = "Hola", "Mundo"
fmt.Println(hello + world) // Con signo solo para cadenas

fmt.Println(hello, world) // Para todo tipo de datos
}
HolaMundo
Hola Mundo
Para concatenar el uso de coma es recomendable ya que si usas el signo +, solo servirá para cadenas pero no para
números, porque con los números se realizara una operación aritmética.
package main
import "fmt"
func main() {
var a, b = 10, 20
fmt.Println(a + b) // Operar datos

fmt.Println(a, b) // Concatenara dato
}
30
10 20
Formateo de información Printf()

El Printf() se usa para imprimir datos formateados, para esto podemos usar algunas caracteres especiales como
para realizar sato de línea. Y también caracteres especiales para formatear información.
 \n : Es una carácter especial que se aplica dentro de comillas y realiza un salto de línea.
 %v : En esta posición podemos imprimir cualquier dato que ese encadenara al final.
package main
import "fmt"
func main() {
var name, age = "Alex", 26
fmt.Printf("Nombre: %v \nEadad: %v", name, age)

}
Nombre: Alex
Eadad: 26

¿Por Qué Go?

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

¿Por Qué Go?

Cargado por

Copyright:

Formatos disponibles

¿Qué es Go o Golang?

¿Por qué Go?

 Velocidad similar a C pero con una sintaxis amigable como Python.

¿Para qué se usa Go?

 Desarrollo web (en lado del servidor)

Configuración de Variables de Entorno en Windows

 GOROOT: En este variable de entorno va la ruta de la instalación C:\Program Files\Go

Estructura de espacio de trabajo de GO

sudo tar -C /usr/local -xzf go1.16.7.linux-amd64.tar.gz

Configuiración de Variables de entorno en Linux

Espacio de Trabajo en Mac

Variables de entorno en Mac

Aqui tenies mas guias para variables entorno https://github.com/golang/go/wiki/SettingGOPATH

Ejeplo de conpilacion en Windows.

C:\Users\roel1\go\src\tutorial-go>go build hola.go

30/09/2021 22:17 <DIR> .

Lenguaje del código: Shell Session (shell)

Comentarios de una linea en Go

package main //Paquete principal

import "fmt" // Importar libreria fmt

 Iint – almacena numero enteros ya sea positivo o negativo

Definición de una variable

Declaración de una variable sin valor inicial

Asignar valores a una variable después de declarar

Definer variables sin tipo de datos

Diferencias ente var y :=

var name = "Alex"

Definir múltiples variables

Ejemplo de múltiples variables de un solo tipo.

Ejemplo de múltiples variables de diferentes tipos de datos.

Regla de nombre de variable

Nombre de variable de varias palabras

const A int = 1 //Constante escrita

Definición de múltiples constantes

Tipos de datos básicos

 Cadena: Representa un valor de cadena de caracteres o texto.

Tipos para números enteros

Enteros con signo

Enteros sin singno

Podemos definir variables que puedan almacenar solo números positivos.

 byte – 8-bits (0 a 255)

Tipo para numeros Flotantes y Complejas

 float32 – 32 bits (-3.4e+38 a 3.4e+38)

var a float32 = 3.56

 Print() : Imprime datos pero al finalizar no hace un salto a la siguiente línea.

Uso del Print()

var hello, world = "Hola", "Mundo"

fmt.Println(hello + world) // Con signo solo para cadenas

fmt.Println(a + b) // Operar datos

Formateo de información Printf()

var name, age = "Alex", 26

fmt.Printf("Nombre: %v \nEadad: %v", name, age)

También podría gustarte