Hola mundo en Go

1

Introducción al Curso de Golang

2

¿Qué es, por qué y quienes utilizan Go?

3

Instalar Go en Linux

4

Instalar Go en Mac

5

Instalar Go en Windows

6

Nuestras primeras líneas de código con Go

Variables, funciones y documentación

7

Variables, constantes y zero values

8

Operadores aritméticos

9

Tipos de datos primitivos

10

Paquete fmt: algo más que imprimir en consola

11

Uso de funciones

12

Go doc: La forma de ver documentación

Estructuras de control de flujo y condicionales

13

El poder de los ciclos en Golang: for, for while y for forever

14

Operadores lógicos y de comparación

15

El condicional if

16

Múltiple condiciones anidadas con Switch

17

El uso de los keywords defer, break y continue

Estructuras de datos básicas

18

Arrays y Slices

19

Recorrido de Slices con Range

20

Llave valor con Maps

21

Structs: La forma de hacer clases en Go

22

Modificadores de acceso en funciones y Structs

Métodos e interfaces

23

Structs y Punteros

24

Stringers: personalizar el output de Structs

25

Interfaces y listas de interfaces

Concurrencia y Channels

26

¿Qué es la concurrencia?

27

Primer contacto con las Goroutines

28

Channels: La forma de organizar las goroutines

29

Range, Close y Select en channels

Manejo de paquetes y Go Modules

30

Go get: El manejador de paquetes

31

Go modules: Ir más allá del GoPath con Echo

32

Modificando módulos con Go

Despedida del curso

33

Despedida

Bonus

34

Cheat Sheet Go

35

Librerías para desarrollo web con Go

36

Data Science con Go

Instalar Go en Linux

3/36
Recursos

Aportes 47

Preguntas 6

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

export GOPATH=$HOME/go
export GOBIN=$GOPATH/bin
export GOROOT=/usr/local/go

export PATH=$PATH:$GOBIN:$GOROOT/bin

😎

Resumen

  1. Descargar la ultima versión de go desde su pagina oficial https://golang.org/dl/

  2. Descomprimir el archivo tar.gz en el directorio /usr/local

  3. En home modificar el archivo .bashrc con visual studio code o cualquier otro editor de texto. Añadiremos las siguientes líneas al final del archivo:

    export GOPATH=$HOME/go
    export GOBIN=$GOPATH/bin
    export GOROOT=/usr/local/go
    
    export PATH=$PATH:$GOBIN:$GOROOT/bin
    

    nota: $HOME= /home/nombre-del-usuario

  4. para ejecutar los cambios realizados usa . .bashrc en el home o también funciona abrir una nueva terminal

  5. verificar que go este funcionando correctamente con go version

  6. en nuestro home crear la carpeta go y dentro de estas las subcarpetas bin pkg src

para generar el entorno de directorios para go

mkdir -p $HOME/go/{bin,pkg,src}

Muchachos, solo deseo que quienes estén pasando por acá, recuerden que el futuro lo tenemos en nuestras manos y hay mucho por hacer, nunca desistan

Yo instale Go hace tiempo en ubuntu, como no sabia lo que se muestra en el video solamente escribi en la terminal “go” y me dio la recomendacion de instalarlo mediante apt sin tener que hacer configuraciones.
Es una buena forma de iniciar o tambien esta la opcion de https://play.golang.org/

Para usuarios de Archlinux (o derivados) simplemente hay que escribir este comando en la terminal:

sudo pacman -S go

Listo, instalado en Windows10 con el subsistema de linux Ubuntu.

Si estan en Debian o en algun derivado(ejm: Ubuntu) pueden simplemente hacer :

sudo apt install golang-go

De esta forma ya no tienen que hacer ninguna configuración extra 😄

Si estas usando el shell zsh entonces debes hacer la connfiguracion dentro de ~/.zshrc y al terminar teclear:

source ~/.zshrc

Asi no tendras que cerrar y abrir la terminal.

Hola, así como existe nvm para poder administrar con facilidad las versiones de node.js en nuestro sistema, tambien existe gvm para Go, sin embargo yo les recomiendo goup que en lo personal me gusta mas y solo ocupo tener esto en mis variables de entorno:

export PATH=$PATH:$HOME/go/bin

Solo una linea, nada mas.

hagan una escuela de go en platzi.com por favor enseñen todo

Hola a todos, les dejo un link relativo a la edición del archivo .bashrc

https://ubunlog.com/bashrc-modifica-prompt-bash/

Saludos

La verdad un mal video, no explico nada, solo se grabo haciendo el procedimiento, tuve que salir a buscar en youutube como instalarlo porque en serio no explico nada, y no fui el unico, en los comentarios se nota que a muchos compañeros les ocurrio lo mismo

instalando linux en WSL…
https://www.youtube.com/watch?v=0e_C1B8fDvg

Les recomiendo montar su ambiente de esta forma en WSL/WIN para evitar montar una VM:
https://www.youtube.com/watch?v=poejKP1wTpc&t=1853s&ab_channel=NicJackson

hi gente, les traigo la instalación en la WSL 2 por si la requieren, good vibes!!!.
https://medium.com/@benzbraunstein/how-to-install-and-setup-golang-development-under-wsl-2-4b8ca7720374

personalmente recomiendo este video. para instalar en ubuntu. https://www.youtube.com/watch?v=E1yiCT2Rdj8

No se si a alguien le sirva, pero yo usé Docker con Vs Code para configurar mi ambiente de desarrollo, desde que aprendí a usarlo no me gusta instalar nada localmente 😅, me costó un poco configurar todo para usar un usuario no root, asi que aqui dejo la declaración de la imagen que use, quizás a algún otro amante de Docker que esté aprendiendo Go le pueda servir de algo. 😬

Hay que cambiar golang_tests por el nombre del workspace de Vs Code para que funcione bien.

FROM golang:1.17rc2

ARG USERNAME=development
ARG WORKDIR=/workspaces/golang_tests

RUN useradd -ms /bin/bash $USERNAME

RUN mkdir -p $WORKDIR

RUN mkdir -p $WORKDIR/go/bin
RUN mkdir -p $WORKDIR/go/pkg
RUN mkdir -p $WORKDIR/go/src

COPY [".","$WORKDIR"]

RUN find "$WORKDIR/" -type d -exec chmod 755 {} \;
RUN find "$WORKDIR/" -type f -exec chmod 755 {} \;

ENV GOPATH="$WORKDIR/go"
ENV GOBIN="$GOPATH/bin"
ENV GOROOT="/usr/local/go"

ENV PATH="$PATH:$GOBIN:$GOROOT/bin"

RUN chown -R $USERNAME $WORKDIR
RUN chmod 755 $WORKDIR

WORKDIR $WORKDIR
USER $USERNAME

En Windows.

C:\Users\chris\OneDrive\Documentos\go>go version
go version go1.17.1 windows/amd64

C:\Users\chris\OneDrive\Documentos\go>dir
 El volumen de la unidad C es OS
 El número de serie del volumen es: F2FF-D8B3

 Directorio de C:\Users\chris\OneDrive\Documentos\go

20/09/2021  15:58    <DIR>          .
20/09/2021  15:57    <DIR>          ..
20/09/2021  15:58    <DIR>          bin
20/09/2021  15:58    <DIR>          pkg
20/09/2021  15:58    <DIR>          src
               0 archivos              0 bytes
               5 dirs  23,620,251,648 bytes libres

👾 Podemos comprobar la versión de Go instalada en nuestro computador, utilizando el siguiente comando:

go version

Como dato, gracias a go modules ya no es necesario poner nuestro codigo en la carpeta src, pero eso se ve mas a delante

Las carpetas creadas dentro de la ruta /home/your_username/go sirven para lo siguiente:

  • bin Guarda todos los binarios o executables creados en Go.
  • pkg Guarda codigo que depende de los Go Modules o dependencias que se utilicen.
  • src Tiene dos funciones. La primera es escribir todo el código desarrollado en Go y la segunda es guardar el conjunto de codigo de librerías de terceros instaladas.
<zypper in go> 

en opensuse

Otra forma de instalar y de que siempre este actualizado es usar:

sudo snap install go --classic 

Esto funciona para distros que viene de Ubuntu/Debian

Hay una forma de instalar GO desde la terminal y es
sudo apt install golang-go

Personalmente me parece mas facil usar un manejador de paquetes o package manager

Algunos ejemplos para algunas distribuciones de Linux son:

Ubuntu-Basadas en Ubuntu-Debian: apt

sudo apt install go

Manjaro: pamac

sudo pamac install go

Arch: pacman

sudo pacman -S go

Solo ejecutas el comando correspondiente a tu distribucion y listo, el se encarga de lo demas

Una vez en home podemos ejecutar el sigueinte comando para crear todas las carpeta de una sola vez:
mkdir go && cd go && mkdir bin pkg src

nano ~/.bashrc

export GOPATH=$HOME/go
export GOBIN=$GOPATH/bin
export GOROOT=/usr/local/go

export PATH=$PATH:$GOBIN:$GOROOT/bin

source ~/.bashrc

Malo, se salta pasos y no se explica bien.
Espero que en las siguientes clases sea mejor.

export GOPATH=$HOME/go
export GOBIN=$GOPATH/bin
export GOROOT=/usr/local/go

export PATH=$PATH:$GOBIN:$GOROOT/bin

<code>


Por si no le entendieron muy bien para qué sirve pkg, este folder guarda Go Packages que son objetos compilados que vienen del folder src. Luego estos packages los pueden incluir y usar dentro del código, para que al momento de compilar, se vincule el ejecutable dentro de pkg a nuestro ejecutable en sí.

Por ejemplo, si estamos haciendo una app que calcule cuánto costará reparar un carro, y ya tenemos un package que genera el presupuesto, este código compilado estaría dentro de pkg, y nosotros podemos incluir este package dentro de nuestro script para usar el generador de presupuestos. Cuando compilemos nuestro código, el package se va a vincular y así únicamente compilamos lo que escribimos, sin necesidad de recompilar el package.

en el video no se explica como abrir el archivo a editar, en esta pagina pueden ver paso a paso como instalar go https://golangdocs.com/install-go-linux

También es posible utilizar un gestor de versiones para Go desde este enlace gvm

Golang _

exportar PATH de go

Para instalarlo en Amazon Linux sólo basta con

sudo yum install golang -y
go version

En la documentación de Go indican ejecutar este comando para descomprimir los archivos descargados

rm -rf /usr/local/go && tar -C /usr/local -xzf go1.16.6.linux-amd64.tar.gz

sin embargo tengan en cuenta que se deben ejecutar con el comando sudo para tener los permisos suficientes en la carpeta /usr/local, adicional tener en cuenta que son dos comandos anidados por una condicional, en conclusión se debe ejecutar:

sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf go1.16.6.linux-amd64.tar.gz

Creamos dentro del home, la carpeta go: Dentro de ella, creamos bin, para guardar nuestros ejecutables y de terceros también. Luego pkg, para guardar algunas partes del código de las librerías que vayas a utilizar y por útlimo scr, para guardar todo el código que vayamos a desarrollar en GO y guardar otro código de liberías de terceros.

Si tienes z shell, entonces solo tienes que poner, en el archivo, .zshrc : export GOPATH=$HOME/go export GOBIN=$GOPATH/bin export GOROOT=/usr/local/go export PATH=$PATH:$GOBIN:$GOROOT/bin... Lo mismo que el profe.

Go es mejor en Linux xD. Así que sí, utiliza Linux.

sudo apt install golang

Instalacion:
Luego de instalar, editar .bashrc, agregando al final:

# GOPATH es el entorno en el cual voy a desarrollar mis programas
export GOPATH=/home/usuario/go

# GOBIN es donde se van a instalar los binarios listos para ser ejecutados en cualquier path
export GOBIN=$GOPATH/bin

# GOROOT indica al runtime donde esta el ejecutador de Go
export GOROOT=/usr/local/go

# Luego las agregamos al path
export PATH=$PATH:$GOBIN:$GOROOT/binarios

Luego, dentro de /home/usuario/go crear tres carpetas:
/bin
/pkg
/src

Instalar GO en WSL de manera sencilla y rápida:
https://www.youtube.com/watch?v=0e_C1B8fDvg

Configuración en archivo .bashrc o .zshrc para poder hacer uso de Go desde la terminal

Recuerden añadir esto a su ~/.bashrc :

export GOPATH=$HOME/go
export GOBIN=$GOPATH/bin
export GOROOT=/usr/local/go

export PATH=$PATH:$GOBIN:$GOROOT/bin

A mi parecer la forma mas facil de añadirlo es con:

vim  ~/.bashrc

Pero pueden usar el editor que quieran 😄

Para los que tienen Debian o derivado. Pueden instalar Go con el clásico y tradicional:
sudo apt install golang-go

Y si utilizan el gestor de paquetes Snap, pueden instalarlo con
sudo snap install go

Y listo, sin configuraciones extra.