Os desenvolvedores podem criar aplicativos de desktop usando várias abordagens: APIs específicas da plataforma, kits de ferramentas de widget nativos, estruturas de desenvolvimento de aplicativos de desktop híbridos. Se planejamos usar APIs específicas de plataforma, geralmente precisamos manter várias bases de código para cada sistema operacional ou usar um kit de ferramentas de widget nativo, como Qt ou GTK, que normalmente são bibliotecas de plataforma cruzada. As últimas opções são populares entre os desenvolvedores porque são fáceis de usar no desenvolvimento de aplicativos de desktop para várias plataformas.

No entanto, os kits de ferramentas de widget nativos são limitados e é difícil para desenvolvedores para criar elementos de GUI personalizados rapidamente ao usá-los. É por isso que bibliotecas e bibliotecas de aplicativos de desktop híbridos são tão populares hoje em dia-eles permitem que os desenvolvedores façam aplicativos de desktop multiplataforma usando JavaScript.

Este tutorial explicará como você pode desenvolver aplicativos de plataforma cruzada para desktop com um front-end JavaScript e back-end Go.

Programação GUI com Go

A linguagem de programação Go é uma linguagem extremamente rápida, segura para a memória, que prioriza a simultaneidade e é tipificada estaticamente. A sintaxe Go é semelhante a C, mas vem com um coletor de lixo e muitas das melhorias que vimos nas linguagens de programação modernas, o que a torna uma boa escolha ao programar elementos de GUI para aplicativos de desktop. É possível usar qualquer estrutura de front-end para criar a GUI se escolhermos a abordagem híbrida, mas existem algumas maneiras diferentes de os desenvolvedores fazerem isso com Go:

• Chamando APIs GUI específicas da plataforma diretamente com Go usando o syscall Módulo e C
• Usando um kit de ferramentas de GUI nativo que tem vínculos para Go, como vínculos Qt para Go
• Criação de aplicativos de desktop com uma biblioteca/estrutura Go, como Lorca e Go webview , que suporta front-ends da web

Neste tutorial, vamos nos concentrar na terceira opção. Lorca e Go webview são duas das bibliotecas Go mais populares para a criação de aplicativos de área de trabalho de plataforma cruzada leves e baseados em JavaScript, porque eles nos permitem realmente usar nosso conhecimento de desenvolvimento da web.

Criação de aplicativos de desktop com a biblioteca Lorca

Lorca é uma biblioteca Go que ajuda os desenvolvedores a criar aplicativos leves de plataforma cruzada para desktop com back-end Go e interface JavaScript.

Lorca não agrupa aplicativos com um navegador da web como o Electron faz-ele usa o navegador Google Chrome instalado para renderizar a interface da web de aplicativos e implementa um canal de mensagens entre JavaScript e Go por meio do protocolo WebSocket . (Se você não tiver o Chrome instalado em sua máquina, ele solicitará que você faça o download; o mesmo vale para os usuários.)

Este canal de mensagem bidirecional ajuda Lorca a chamar o código nativo de um front-end da web. Este conceito foi inicialmente implementado pelo Google com sua biblioteca de Carlo , exceto Carlo usado Node para o back-end, em vez de Go. (O projeto Carlo não é mais mantido ativamente . )

Agora, vamos criar um aplicativo Lorca simples. Nosso aplicativo de amostra exibirá “Olá, [nome de usuário],” na inicialização, usando uma chamada nativa para buscar o nome de usuário atual do seu sistema operacional.

Configurando os ambientes de desenvolvedor Go e Lorca

Lorca não tem dependências especiais, então você só precisa instalar as ferramentas de linguagem Go em seu computador para fazer aplicativos Lorca. Você pode baixar e instalar as ferramentas de linguagem Go diretamente do site oficial.

Após o processo de instalação, execute o seguinte comando para se certificar de que o Go CLI funciona.

 versão $ go

Criando uma janela Lorca

Vamos nos familiarizar com Lorca. Crie um novo diretório e, em seguida, crie um arquivo main.go dentro do diretório recém-criado. Depois disso, adicione o seguinte código ao arquivo main.go :

 pacote principal
importar ( "registro" "net/url" "github.com/zserge/lorca"
)
func main () { //Passe HTML do URI de dados. ui, err:=lorca.New ("data: text/html,"+ url.PathEscape (`      
 Olá, Lorca! 
   `),"", 600, 400) se errar!=nulo { log.Fatal (err) } adiar ui.Close () <-ui.Done ()
}

O método lorca.New cria uma janela mínima do Chrome, enviando a configuração necessária, como tamanho da janela e URL, como argumentos de linha de comando para o binário do Google Chrome. Por exemplo, os valores de largura e altura são enviados ao binário do Google Chrome como --window-size=600.400 .

Execute os seguintes comandos para executar seu aplicativo. Observe que você precisa executar $ go get apenas na primeira vez que usar Lorca porque o compilador da linguagem Go precisa baixar o código Lorca do GitHub. Mais tarde, Go irá lê-lo do disco rígido.

 $ vá buscar
$ go run main.go

Este aplicativo carrega o front-end a partir de um URI de dados HTML, mas os front-ends da web geralmente contêm vários recursos. Na próxima parte, vamos estender este aplicativo para oferecer suporte a front-ends comuns da web, implementando um servidor de arquivos estático para servir aos nossos recursos da web.

Implementando o back-end

Agora, vamos implementar um servidor de arquivos estático para servir ao nosso front-end da web. Também exporemos uma nova função Go para o front-end da web para obter o nome de usuário atual do sistema operacional. Modifique seu arquivo main.go adicionando o seguinte código:

 pacote principal
importar ( "registro" "internet" "net/http" "fmt" "tempo de execução" "os" "github.com/zserge/lorca"
)
func getUserName () string { var envKey string if runtime.GOOS=="windows"{ envKey="NOME DE USUÁRIO" } senão { envKey="USUÁRIO" } return os.Getenv (envKey)
}
func main () { //Passe HTML do URI de dados. ui, err:=lorca.New ("","", 600, 400) ui.Bind ("getUserName", getUserName) se errar!=nulo { log.Fatal (err) } ln, err:=net.Listen ("tcp","127.0.0.1:0") se errar!=nulo { log.Fatal (err) } adiar ln.Close () acesse http.Serve (ln, http.FileServer (http.Dir ("./www"))) ui.Load (fmt.Sprintf ("http://% s", ln.Addr ())) adiar ui.Close () <-ui.Done ()
}

Implementando o front-end

O código Go acima tem um servidor de arquivo estático que atende a todos os recursos dentro do diretório www , o que significa que é possível colocar qualquer recurso da web dentro do diretório www . Coloque um arquivo chamado index.html dentro do diretório www com o seguinte código:

Lorca expõe a função getUserName Go como uma função assíncrona para o frontend. Da mesma forma, você pode expor qualquer método Go para o front-end em Lorca. Execute o arquivo main.go para testar seu aplicativo.

Você também pode ver a saída do console da web no terminal onde executou o comando go run .

Construindo e lançando seu aplicativo

Você pode compilar os arquivos de origem Go para obter uma versão executável do seu aplicativo Lorca. O comando a seguir tornará um executável otimizado para seu sistema operacional atual.

 $ go build-ldflags"-s-w"main.go

Depois de executar o comando acima, você notará um novo arquivo binário chamado main dentro do diretório do seu projeto. Clique duas vezes e abra o arquivo binário para abrir seu aplicativo Lorca. O tamanho do arquivo binário é de cerca de 7 MB-notavelmente menor do que os tamanhos de pacote que Electron e NW.js produzem.

Sinta-se à vontade para usar a compressão UPX para reduzir ainda mais o tamanho binário. Se quiser manter seus arquivos de origem JavaScript ocultos, incorpore seus recursos ao arquivo de origem Go conforme descrito no primeiro exemplo.

Você pode fazer instaladores ou pacotes para seu aplicativo usando seus binários. Por exemplo, é possível fazer um AppImage para usuários Linux, um pacote MSIX para usuários Windows e um pacote de instalação DMG para usuários MacOS.

Criação de aplicativos de desktop com a biblioteca Go webview

Lorca usa o navegador Google Chrome instalado como a camada da IU. O Google Chrome é executado em um processo separado, portanto, não podemos personalizar a janela nativa. Em outras palavras, os aplicativos Lorca não podem ter ícones de janela personalizados, estilos de janela etc.

Com Lorca, você precisa do Google Chrome para executar aplicativos, mas a biblioteca Go webview usa o componente de navegador integrado do sistema operacional para fazer isso e cria uma janela nativa usando as APIs específicas da plataforma.

Se você está planejando construir um aplicativo de desktop híbrido tipo nativo para vários sistemas operacionais, a biblioteca Go webview é uma ótima alternativa para a biblioteca Lorca. A biblioteca Go webview usa a biblioteca webview C ++ feita pelo mesmo desenvolvedor. Tauri e frameworks Neutralinojs são desenvolvidos com a biblioteca webview C ++.

Criação de um aplicativo Go webview simples

A biblioteca Go webview oferece uma API semelhante à Lorca, e a configuração do ambiente de desenvolvedor é a mesma. Vamos prosseguir e construir um pequeno aplicativo com a biblioteca Go webview.

Adicione o seguinte código ao arquivo main.go , semelhante ao que fizemos no primeiro exemplo.

 pacote principal
importar ( "net/url" "github.com/webview/webview"
)
func main () { depurar:=verdadeiro w:=webview.New (depurar) adiar w.Destroy () w.SetTitle ("Go webview app") w.SetSize (600, 400, webview.HintNone) w.Navigate ("data: text/html,"+ url.PathEscape (`   
 Olá, vá para o webview! 
   `)) w.Run ()
}

Os comandos de terminal a seguir irão executar seu aplicativo; a mesma observação sobre $ go get se aplica aqui também:

 $ vá buscar
$ go run main.go

O processo de construção e lançamento é o mesmo que descrevi no tutorial Lorca. O tamanho do arquivo binário para o exemplo de visualização da web Go deve ser em torno de 2 MB, mas observe que pode variar de acordo com as bibliotecas Go que você usa.

Lorca e Go webview vs. outras estruturas Go

Lorca e Go webview são bibliotecas, não frameworks. Em outras palavras, ambas as bibliotecas oferecem apenas uma solução mínima para o desenvolvimento de aplicativos de desktop multiplataforma baseado em JavaScript. Existem também estruturas Go para construir aplicativos de desktop baseados em JavaScript, como Wails , um Go framework baseado em webview para construir aplicativos de desktop multiplataforma com JavaScript. Escolher uma biblioteca em vez de uma estrutura ajudará você a criar aplicativos de área de trabalho leves e muito personalizáveis.

Conclusão

Embora não haja uma API nativa completa como o Electron, a grande vantagem aqui é que você pode ser mais seletivo e incluir apenas o que precisa no pacote final do aplicativo. Como discutimos, a personalização de janela nativa de Lorca é limitada porque usa diretamente o processo do Google Chrome, enquanto Go webview expõe o manipulador de instância de janela para personalização de janela nativa. Apesar dessas limitações, essa abordagem realmente funciona quando você deseja evitar o carregamento de seu aplicativo com código não utilizado em excesso e quando precisa que seu aplicativo final seja muito menor do que o que o Electron poderia produzir.

A postagem Como para desenvolver aplicativos de plataforma cruzada para desktop com JavaScript e Go apareceu primeiro no LogRocket Blog .