Guia Programacion en Go Lang
Go es un lenguaje de programación concurrente y compilado, inspirado en el lenguaje C, pero intenta ser dinámico como Python y con el rendimiento de C o C++.
En este articulo vamos a ver como instalar el lenguaje GO en Windows 10, en mi caso.
Go es un lenguaje relativamente nuevo, creado el 2009, tiene 12 años de su creacion, en comparacion de Python creado en el 1991 que tiene 31 años, y el lenguage C que tiene 50 años desde su creacion.
Go es un lenguaje que esta cobrando relevancia cada dia mas y algunas empresas lo solicitan.
Go es un lenguaje flexible que se puede usar para la programación de sistemas, big data, aprendizaje automático, inteligencia artificial y mas.
Descargar e Instalar Go
Para descargar el lenguaje Go vamos a ir a su pagina oficial y en la sección de descargar buscaremos la opción, recomendable la versión estable mas reciente para nuestro sistema de 32 o 64 bits. 64 bits en mi caso.
Link: Pagina oficial de Go
Vamos a descargar un archivo instalable en Windows.
Este archivo puede ser .exe o .msi lo ejecutamos y procedemos a hacer la instalación.
La instalación es una instalación clásica de Windows, siguiente, acepto, siguiente, siguiente, finalizar…
Una vez finalizada la instalación ya podemos crear y ejecutar archivos *.go
Los archivos .go normalmente los vamos a ejecutar en la terminal (cmd.exe o powershell)
Escribir y Ejecutar Hola Mundo en Go
El codigo basico del hola mundo en Go es el siguiente.
package main
import "fmt"
func main(){
fmt.Println("Hola, Mundo!!")
}
La sintaxis nos recuerda un poco a C, por la funcion main, pero con la palabra import (como en python) para importar librerias de sistema o de terceros.
La libreria “fmt” de Go incluye funciones de formato por ejemplo: Println, Printf, Sprintf, Scan, Scanf, …etc. mas adelante veremos mas a detalle.
En el caso de la función fmt.Println(texto) escribimos el texto que queremos imprimir entre comillas.
Eso es por la parte del codigo.
Ahora para ejecutar el codigo.
Vamos a guardar el codigo en un archivo por ejemplo hola.go u hello.go o como ustedes quieran.
Vamos a buscar en la terminal la ubicacion donde guardaron el archivo, por ejemplo: C:\Users\evilnapsis\goscripts\
Donde “evilnapsis” es el nombre de mi usuario en windows, para ustedes les va a aparecer otro nombre de usuario.
Una vez ubicados ahi en la terminal vamos a ejecutar el comando.
go run hello.goY veremos el resultado.
Leer Datos del Teclado en Go
La funcion o metodo Scan de go es parte de la libreria principal fmt la misma que se usa para Println.
Para usar la funcion Scan es necesario declarar el tipo de dato que se va a leer y pasar el parametro a la funcion Scan con el operador de puntero &
package main
import "fmt"
func main() {
fmt.Println("## Probando Scan ##\n")
var name string // Definimos la variable donde se guardaran los datos
fmt.Print("Cual es tu nombre ? ")
fmt.Scan(&name) // Leemos los datos
fmt.Printf("Hola %s , un gusto conocerte! \n", name) // Imprimimos los resultados
}
En el ejemplo podemos ver que usamos un Print para hacerle una pregunta al usuario, posteriormente escaneamos los datos y lo pasamos como valores despues en un Printf , recordemos que el operador %s sirve para mostrar cadenas de texto.
El siguiente ejemplo o pieza de codigo, hace la misma funcion que arriba solo que ahora vamos a leer un valor entero o numerico.
var age int
fmt.Print("Cual es tu edad ? ")
fmt.Scan(&age)
fmt.Printf("Veo que tienes %d años, que bien! \n", age)
Esta parte nos pregunta la edad y posteriormente la muestra.
Ciclo For en Go
El ciclo for en go nos permite repetir un bloque de instrucciones o codigo mientras se cumpla una condicion.
En el siguiente ejemplo veremos un ciclo en Go y las diferencias que hay respecto a otros lenguajes.
package main
import "fmt"
func main() {
fmt.Println("Probando ciclos")
for i := 0; i < 10; i++ {
fmt.Println("Iteracion :", i)
}
}
El bloque del ciclo for es el siguiente:
for i := 0; i < 10; i++ {
fmt.Println("Iteracion :", i)
}
Lo que hacemos en este codigo es empezar con la variable i con valor en cero, el ciclo se va a repetir mientras i sea menor que 10 (i<10) y en cada repeticion del ciclo se le va a sumar 1 a la variable i.
Otra forma de implementar el cliclo for es como si se tratara de un while, en el lenguaje go no existe la sentencia while por lo tanto se usa el ciclo for de la siguiente manera.
n := 0 // inicializacion de variable
for n < 10 { // inicio del ciclo y comparacion para terminar el ciclo
fmt.Println("Iteracion: ", n)
n++ // incrementar o hacer operaciones con la variable a comparar
}
Para ejecutar el script debemos ejecutar el comando:
go run for1.go
Donde for1.go es el nombre del script con el cual guardamos el script.
Arrays en Go
Los arrays en Go son estructuras para manejar o guardar listados de datos, en go los arrays son inmutables es decir una vez creado no se puede modificar el tamaño.
Los arrays en Go funcionan muy similar a los arrays en C ya que estos tienen que ser del tipo que fueron especificados / inicializados.
Es decir un array de enteros solo admite enteros y un array de cadenas o string solo admite cadenas o strings.
Definir un Array en Go
Para definir el array hay 2 formas.
La primera se crea el array con su tipo y tamaño.
var myarray [5]int
El array de tipo entero en este caso tiene 5 espacios, para acceder a los espacios o valores del array se usan corchetes[] , el primer valor/indice siempre es 0 y el ultimo valor o indice sera N-1, si en este caso N=5, entonces el ultimo indice seria N-1=5-1 = 4.
Cuando declaramos un array de esta forma, todos los valores se asignan en 0 si son enteros.
Otra forma de inicializar el array es declarando y asignando valores en la misma linea.
myarray := [5]int{1, 2, 3, 4, 5}Con este forma es mas rapido si ya conocemos los valores que va a tener cada array.
La forma clasica de asignar los valores es usando los corchetenes y su indice de la siguiente manera.
myarray[0] = 10 myarray[1] = 100 myarray[2] = 1000 myarray[3] = 10000 myarray[4] = 100000
Y con esto ya tenemos definido y asignado los valores de nuestro array.
Recorrer un array en Go
Una vez que ya rellenamos nuestro array de datos lo mas comun seria recorrer tenemos 2 formas, podemos inventar otra forma, pero vamos con las 2 basicas.
Usando un for clasico y usamos la funcion len() para calcular el tamaño de nuestro array, si el tamaño del array ya lo conocemos pues en lugar de len(myarray) ponemos el valor del tamaño delñ array.
for i := 0; i < len(myarray); i++ {
fmt.Println(myarray[i]) // imprimimor el valor
}
La segunda forma se utiliza for y la funcion range para recorrer el array.
En esta forma no es necesario definir variable de inicio, ni condicion , ni incrementar , del for.
for i := range myarray {
fmt.Println(i, myarray[i]) // imprimimos el indice y el valor
}
El resultado seria aproximadamente el siguiente.
C:\Users\evilnapsis\scripts>go run arrays1.go
Arrays en GO
Imprimir con For clasico
10
100
1000
10000
100000
Otra forma de For
0 10
1 100
2 1000
3 10000
4 100000
C:\Users\evilnapsis\scripts>Leer un archivo de texto en Go
Para leer un archivo de texto en Go vamos a usar los modulos “fmt”, “io” y “os”, primero vamos a abrir el archivo para obtener el descriptor de archivo y despues lo vamos a leer o recorrer con la funcion ReadAll().
Para el ejemplo voy a usar un archivo llamado archivo.txt con el siguiente contenido.
Argentina
Brazil
Chile
Colombia
Mexico
Peru
Venezuela
Ustedes pueden usar el archivo que mejor les parezca.
Para leer el archivo vamos a usar el siguiente codigo, le agregue comentarios para entenderlo mas facil.
package main
import ( // Importamos los modulos necesarios
"fmt"
"io"
"os"
)
func main() {
f, error := os.Open("archivo.txt") // Abrimos el archivo "archivo.txt"
if error != nil { // Si ocurre un error lo mostramos
fmt.Println(error)
}
data, error2 := io.ReadAll(f) // Leemos el archivo apartir del descirptor
if error2 != nil { // Si ocurre algun error lo mostramos
fmt.Println(error2)
}
data_string := string(data) // Convertimos los datos a string
fmt.Println(data_string) // Mostramos el resultado
}
Y listo solo tenemos que ejecutar el script y leera el archivo y al final se mostrara el resultado.
Conclusión
Como hemos visto, Go es un lenguaje diseñado para la eficiencia. Su sintaxis minimalista y su capacidad para compilar binarios de alto rendimiento lo convierten en una opción poderosa tanto para herramientas de automatización como para sistemas de gran escala.
Aunque lenguajes como C y Python siguen siendo pilares fundamentales, Go ocupa un lugar único: nos ofrece la seguridad y velocidad que exige la programación de sistemas moderna, sin la complejidad innecesaria de otros lenguajes.
