O poder e a simplicidade da Linguagem Go
Olá, mundo!
Como vão?
Introdução
As linguagens de programação existem seus paradigmas, como as procedurais, orientação a objetos, estruturadas, dentre outras. Cada qual atendem a uma realidade diferente, na Web, por exemplo, a Orientação a Objetos veio com as grandes linguagens já consolidadas: PHP, Java, C#, Javascript, Python e Ruby. Dependendo do cenário em que você está, é interessante utilizar outras linguagens para complemento e, por buscas de melhorias de desempenho com o intuito de deixar ela sempre disponível.
Para fique claro, imagine que você tem uma série de solicitações de usuários, e estes registram em seu banco de dados, no entanto se utilizarmos a aplicação para tal, dependendo da estrutura de seus servidores, haverá um grande gargalo, existem extensões do PHP, feitas em C, por exemplo que resolvem estas premissas, como o OpenSwoole. Focada na Arquitetura de microsserviços, também há no ecossistema Laravel o Laravel Octane, que tem a mesma intenção. Nesta breve introdução, podemos ter a real noção do que podemos propor de cenário complexo, com alta disponibilidade, é assim que grandes aplicações rodam, como Facebook, Google, Wikipedia, Instagram, etc.
Diante desta breve explanação, apresento a Linguagem Go. Uma linguagem compilada (caso queira saber mais, clique aqui, com o paradigma estrutural e absurdamente rápida.
Ola_mundo.go
package main
import "fmt"
func main() {
fmt.Println("Olá, Mundo com Go!")
}
Como a consagrada Linguagem C, para a sua execução é necessária a definição do método Main(), além de importar as bibliotecas, neste caso a que manipula entrada e saída de dados a fmt, através da palavra reservada import.
Para compilar executamos este comando:
go build
Deverá gerar um binário, no nosso exemplo o Ola_mundo:
Como podem observar, a compilação e a execução é absurdamente rápida. Isso se dá pelo compilador moderno ser bem eficiente.
Vamos ao Trabalho\\
Veja como é simples fazer uma rotina, como fizemos no post anterior para calcular o fatorial, é tão simples como C, PHP, e Basic:
package main
import "fmt"
func main() {
var num_fatorial, fatorial int
fatorial = 1
fmt.Print("Digite o número para calcular seu fatorial = ")
fmt.Scanln(&num_fatorial)
for i := 1; i <= num_fatorial; i++ {
fatorial = fatorial * i
}
fmt.Println("A Fatorial de ", num_fatorial, " é = ", fatorial)
}
Como podemos observar, a Go é extremamente simples para escrever e rápida em seu tempo de execução.
Posto de forma simples, um compilador é um programa que lê um programa escrito numa linguagem – a linguagem-fonte – e o traduz num programa equivalente numa outra linguagem – a linguagem-objeto. Como importante parte desse processo de tradução, o compilador relata a seu usuário a presença de erros no programa-fonte. – Compiladores: Princípios, Técnicas e Ferramentas.
Mas antes de mais nada, por qual razão faço teste de iteratividade, no caso com Fatorial? Simples, testamos o desempenho do comportamento da execução do código, falei um pouco sobre o gerenciamento de memória neste post aqui. Além da disposição da Memória, o emprego da CPU com o código otimizado para cada arquitetura.
Existem inúmeras bibliotecas feitas pela comunidade que atendem as mais diversas necessidades, como a Fyne que provê uma série de widgets para você criar interfaces gráficas com Golang.
Antes de mais nada, como estou usando ambiente Linux, se faz necessária a instalação das seguintes bibliotecas:
sudo apt-get install gcc libgl1-mesa-dev xorg-dev
Se sua distribuição for Debian-like, como Ubuntu, o próprio Debian e o Mint, ele instalará o Compilador GNU, e as bibliotecas de manipulação e interface Gráfica.
Vamos a um exemplo:
//Editor de Texto código Por: https://blogvali.com/
package main
import (
"fmt"
"io/ioutil"
"os"
"strconv"
"fyne.io/fyne/v2"
"fyne.io/fyne/v2/app"
"fyne.io/fyne/v2/container"
"fyne.io/fyne/v2/dialog"
"fyne.io/fyne/v2/storage"
"fyne.io/fyne/v2/widget"
)
var count int = 1
var filepath string
func main() {
a := app.New()
w := a.NewWindow("Notepad Fyne em GO")
input := widget.NewMultiLineEntry()
input.SetPlaceHolder("Escreva sua anotações...")
input.Move(fyne.NewPos(0, 0))
input.Resize(fyne.NewSize(500, 500))
new1 := fyne.NewMenuItem("Novo", func() {
filepath = ""
w.SetTitle("Notepad Fyne")
input.Text = ""
input.Refresh()
})
save1 := fyne.NewMenuItem("Salvar", func() {
if filepath != "" {
f, err := os.OpenFile(filepath, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
//handle error
}
defer f.Close()
//f.Write([]byte(input.Text))
f.WriteString(input.Text)
} else {
saveFileDialog := dialog.NewFileSave(
func(r fyne.URIWriteCloser, _ error) {
textData := []byte(input.Text)
r.Write(textData)
filepath = r.URI().Path()
w.SetTitle(filepath)
}, w)
saveFileDialog.SetFileName("Novo Arquivo" + strconv.Itoa(count-1) + ".txt")
saveFileDialog.Show()
}
})
saveAs1 := fyne.NewMenuItem("Salvar Como..", func() {
saveFileDialog := dialog.NewFileSave(
func(r fyne.URIWriteCloser, _ error) {
textData := []byte(input.Text)
r.Write(textData)
filepath = r.URI().Path()
w.SetTitle(filepath)
}, w)
saveFileDialog.SetFileName("Novo Arquivo" + strconv.Itoa(count-1) + ".txt")
saveFileDialog.Show()
})
open1 := fyne.NewMenuItem("Abrir", func() {
openfileDialog := dialog.NewFileOpen(
func(r fyne.URIReadCloser, _ error) {
data, _ := ioutil.ReadAll(r)
result := fyne.NewStaticResource("nome", data)
input.SetText(string(result.StaticContent))
fmt.Println(result.StaticName + r.URI().Path())
filepath = r.URI().Path()
w.SetTitle(filepath)
}, w)
openfileDialog.SetFilter(
storage.NewExtensionFileFilter([]string{".txt"}))
openfileDialog.Show()
})
menuItem := fyne.NewMenu("Arquivo", new1, save1, saveAs1, open1)
menux1 := fyne.NewMainMenu(menuItem)
w.SetMainMenu(menux1)
w.SetContent(
container.NewWithoutLayout(
input,
),
)
w.Resize(fyne.NewSize(500, 500))
w.ShowAndRun()
}
Veja que em poucas linhas já foi possível fazer um Editor de Textos que realiza todas as funcionalidades de um Bloco de Notas do Windows, por exemplo.
Ela abre muitas possibilidades de criação, como neste código enxuto em que cria um Editor de Textos, aplicações complexas como o Docker, por exemplo, é escrito em Go. Tenho adotado ela em alguns projetos, ainda tenho meus amores ao PHP, mas já penso em fazer algumas API Rest em Go! ; )
É isso, espero que tenha sido de grande ajuda.
O amor é paciente, o amor é bondoso. Não inveja, não se vangloria, não se orgulha. Não maltrata, não procura seus interesses, não se ira facilmente, não guarda rancor. O amor não se alegra com a injustiça, mas se alegra com a verdade. Tudo sofre, tudo crê, tudo espera, tudo suporta.
1 Coríntios 13:4-7