El lenguaje de programación Go de Google existe desde 2009 y en 2012, el lenguaje alcanzó su estado oficial v1.0. En esos años intermedios, mucho ha cambiado, incluida la forma en que se instala el idioma. En sus inicios, no había distribuciones binarias oficiales y tenía que compilar Go a partir del código fuente, que era el método recomendado ya que el idioma cambiaba con frecuencia, o usar un paquete preconstruido para su distribución de Linux. En aquel entonces, la compatibilidad con Windows era limitada, al igual que la compatibilidad con arquitecturas de CPU distintas de Intel.
Las cosas han mejorado mucho desde entonces. Para Linux, hay dos formas sencillas de instalar Go. Descargue la compilación binaria oficial de Linux desde la página de descargas de Go u opte por un paquete prediseñado para su distribución de Linux. La forma más fácil de instalar Go en Ubuntu es usar apt-get:
sudo apt-get install golang
Una vez que se instala Go, puede comenzar a desarrollar programas. Uno de los programas Go más simples es el clásico «¡Hola mundo!» programa. Usando un editor de texto, cree un archivo llamado «hellomte.go” con el siguiente código Go corto:
package main
import "fmt"
func main() {
fmt.Println("Hello Make Tech Easier!")
}
Desde la v1.0 de Go, se eliminó la necesidad de compilar y vincular comandos individuales y el antiguo 8g y 8l Los comandos han sido reemplazados por los go dominio.
Correr hellomte.goabra una terminal y cambie el directorio a la carpeta que contiene el archivo de código fuente, luego escriba:
Esto compilará y ejecutará el programa Go pero no producirá un binario ejecutable. Para crear un binario y luego ejecutarlo, use el go build dominio:
go build hellomte.go ./hellomte
El poder de la concurrencia
Una de las características definitorias del lenguaje de programación Go es su compatibilidad con la concurrencia, lo que permite que un programa funcione con múltiples tareas a la vez. El paralelismo, que es similar a la concurrencia, permite que un programa ejecute muchas tareas simultáneamente, pero la concurrencia va un paso más allá ya que permite que estas tareas separadas se comuniquen e interactúen. Como resultado, Go permite a los programadores usar una gran variedad de diferentes diseños simultáneos, incluidos grupos de trabajadores, canalizaciones (donde una tarea ocurre tras otra) y tareas en segundo plano sincrónicas o asincrónicas. El fundamento de esta concurrencia es la goroutine junto con channels y ir select declaración.
Aquí hay un programa Go simple que imprime una cadena varias veces usando una rutina go concurrente:
package main
import (
"fmt"
"time"
)
func say(s string) {
for i := 0; i < 5; i++ {
fmt.Println(s)
}
}
func main() {
go say("Hello Make Tech Easier!")
fmt.Println("Sleep a little...")
time.Sleep(100 * time.Millisecond)
}
La función say() simplemente realiza un ciclo simple para imprimir la cadena (parámetro s) cinco veces. Lo interesante es cómo se llama esa función. En lugar de simplemente llamar say("Hello Make Tech Easier!") la palabra clave go se coloca delante de la llamada de función. Esto significa que la función se ejecutará como una tarea separada. El resto de main() entonces solo duerme un poco para dar tiempo a la goroutine completar.
El resultado puede sorprenderte:
Como puedes ver el say() la función se ejecuta como goroutine y mientras se configura el resto del main() la función continúa, imprimiendo Sleep a little... y luego ir a dormir. Para entonces el goroutine está activo y comienza a imprimir la cadena cinco veces. Finalmente, el programa finaliza una vez que se alcanza el límite de tiempo de espera.
Canales
goroutines puede comunicarse usando canales. Un canal abre una línea de comunicación entre dos partes diferentes de un programa Go. Por lo general, una función se llamará como goroutine y si necesita devolver datos (por ejemplo, desde una operación de red), puede usar un canal para transmitir esos datos. Si otra parte del programa Go está esperando esos datos, se suspenderá hasta que los datos estén listos. Los canales se crean usando el make() función y se pueden pasar como parámetros a goroutines.
Considere este código:
package main
import (
"fmt"
)
func say(s string, c chan int) {
var i int
for i = 0; i < 5; i++ {
fmt.Println(s)
}
c <- i
}
func main() {
c := make(chan int)
go say("Hello Make Tech Easier!", c)
sts := <- c
fmt.Println(sts)
}
los say() La función es muy similar al primer ejemplo con la excepción de que el segundo parámetro es un canal y que después de imprimir la cadena, el número de iteraciones se enviará por el canal a través del c <- i línea de código.
La función principal crea un canal, inicia el say() funcionar como un goroutine y luego espera a que los datos lleguen al canal, sts := <- c antes de imprimir el resultado.
Conclusión
El lenguaje Go ha progresado significativamente en los últimos años, si no lo ha visto recientemente, ¡quizás ahora sea un buen momento!