Ambientes de Desenvolvimento: Configuração para Programação em Lua

Pré-Requisitos

Os pré-requisitos para iniciar as atividades de programação em Lua são semelhantes aos descritos para JavaScript e Python: um editor de texto e um interpretador, ou um Ambiente Integrado de Desenvolvimento (em inglês, Integrated Development Environment ou IDE).

Caso queira evitar a configuração inicial, você pode usar o editor e interpretador de código Lua fornecido neste website para uso online em seu navegador. Todavia, em algum momento você precisará configurar um ambiente de programação em sua máquina.

Para evitar repetir as discussões feitas anteriormente para JavaScript e Python:

• Se você já possui um editor de texto, a instalação do interpretador de Lua é simples. Ao contrário de outras linguagens, o interpretador de Lua pode ser tão simples quanto um único arquivo executável e autocontido;
• Se você preferir usar um IDE, a opção mais simples é escolher ZeroBrane Studio, que inclui, dentre outros, editor de texto, interpretador e depurador;
• Se você não sabe como instalar programas, o que é PATH ou como configurá-lo, consulte a entrada sobre instalação de programas.

Parte do conteúdo desta página será idêntico ao conteúdo de Python. Portanto, caso alguns parágrafos sejam familiares, não será impressão, mas um certo déjà vu. Por sinal, isso também ocorrerá em novas entradas sobre ambientes de desenvolvimento em outras linguagens de programação. Afinal, os procedimentos para configuração são similares.

Versão em Vídeo

Esta entrada possui uma versão em vídeo disponível no canal do YouTube. Embora esta versão em texto seja mais completa, você pode seguir o vídeo primeiro, caso preferir.

Sobre Lua

Lua é uma linguagem de programação brasileira (criada e mantida pela PUC-Rio). Como Python, Lua é uma linguagem com sintaxe concisa e elegante. De fato, Lua prima pela simplicidade.

A gramática de uma linguagem de programação determina as regras para a escrita de código considerado válido para a linguagem. A gramática de Lua é compacta e limpa, ocupando cerca de pouco mais de uma página em formato A4 na versão 5.1 e cerca de uma página e meia em formato A4 na versão 5.4 para a sua definição formal.

Na minha opinião, código em Python assemelha-se mais com pseudocódigo que em Lua, mas a sintaxe de Lua também lembra a de um algoritmo. Enquanto Python utiliza espaçamentos para definir blocos e escopos, Lua utiliza palavras-chaves escritas, algo que pode ser interessante para pessoas que façam uso de leitores de tela para programar. De fato, existem sistemas (como BlindOS) que utilizam Lua para ambientes programáveis para pessoas cegas. Embora eu não recomende, o uso de palavras para blocos também pode ser uma alternativa para pessoas que queiram programar usando dispositivos móveis, dado que o acesso a símbolos como chaves requer toques extras em muitos teclados virtuais.

De certa forma, Lua é antítese de Python quanto às bibliotecas fornecidas por padrão: ao invés de oferecer baterias inclusas como Python, Lua fornece um ambiente minimalista para programação. Isso torna a linguagem uma excelente opção para uso dentro de outros programas, potencialmente escritos em outras linguagens de programação. Além disso, Lua (particularmente LuaJIT) tem como diferencial ser uma linguagem rápida para scripting.

A combinação dos dois fatores resulta na escolha de Lua como linguagem integrada em programas de alto desempenho. Partes do programa nas quais o desempenho seja essencial podem ser escritas em linguagens como C ou C++ As demais partes podem ser escritas em Lua. Por exemplo, existem vários jogos digitais que permitem a criação de conteúdo em Lua (prática conhecida como modding), ao passo em que o motor é escrito em uma linguagem como C++.

Embora a biblioteca padrão de Lua seja enxuta, existem bibliotecas externas para uso. Por exemplo, o projeto Lua Rocks reúne bibliotecas prontas para uso. O ambiente Lua for Windows lista e reúne bibliotecas úteis em uma única distribuição, como tentativa de ser uma versão de Lua com baterias inclusas.

A documentação de Lua está disponível online. Existem traduções para Português para as versões 5.1 e 5.2. Para versões mais recentes, deve-se consultar a versão em Inglês.

Versões

Pode-se obter a versão mais recente de Lua na página oficial do projeto. Contudo, é bastante comum que aplicações que embutam Lua em outras linguagens de programação adotem a versão 5.1, usada por LuaJIT.

No geral, para se aprender a linguagem, tanto a versão 5.1 quanto versões mais recentes são adequadas. Embora a versão 5.1 seja similar às versões mais atuais, existem algumas diferenças. As versões mais recentes possuem alguns recursos adicionais (como suporte a Unicode, números inteiros como um tipo e constantes).

Para links para documentação apresentados nesta página, utilizar-se-á a tradução para Português presente nos manuais da versão 5.1 quando disponíveis, usando versões posteriores em Inglês quando necessário.

Interpretador e Editor de Texto

Deve-se usar contas de root ou de administrador apenas para instalar o interpretador. Após instalá-lo, use uma conta de usuário comum, sem privilégios mais altos, para usar o interpretador e programar.

Linux

Assim como Python, é simples instalar Lua em distribuições Linux com gerenciadores de pacotes. Alguns exemplos para distribuições populares:

1. Arch Linux:

   pacman -S lua

   O parâmetro lua instala a última versão. Outras versões da linguagem (como lua51 para a versão 5.1) também estão disponíveis, além de luajit.

2. Debian, Ubuntu ou distribuições baseadas nas anteriores:

   apt-get install lua5.4

3. Fedora:

   dnf install lua

4. Gentoo:

   emerge --ask dev-lang/lua

macOS

Em ambientes macOS, pode-se usar brew para instalar Lua.

Windows

No Windows, a forma de instalação tradicional consiste em baixar o interpretador da página oficial. Arquivos pré-compilados e prontos para o uso estão disponíveis em na página de downloads de LuaBinaries.

Para obter os arquivos, escolha a versão mais recente (ou a versão anterior que quiser). Os arquivos relevantes serão, tomando como exemplo a versão 5.4.2:

• lua-5.4.2_Win32_bin.zip para sistemas 32-bit;
• lua-5.4.2_Win64_bin.zip para sistemas 64-bit. Exceto caso seu computador seja muito antigo, é provável que seu sistema seja 64-bit.

Após escolher um arquivo, aguarde alguns instantes para o download começar. Após o download terminar, deve-se extrair o arquivo. O diretório de extração será o local para uso do arquivo.

Ao contrário de outras linguagens de programação, o interpretador de Lua é um arquivo autocontido. Após extrair os arquivos no diretório de sua escolha, use o programa lua54.exe (o número pode variar de acordo com a versão). O interpretador para Lua está pronto para uso.

Caso queira adicionar o interpretador ao PATH, consulte instalação de programas.

Alternativas para instalar o interpretador em Windows incluem:

• Chocolatey ou Scoop;
• Usar um IDE com o interpretador integrado (por exemplo, ZeroBrane Studio).

Teste de Ambiente

Com o interpretador instalado, pode-se começar a programar em Lua. Para iniciar o interpretador, use o arquivo executável obtido ou digite lua seguido por enter em um interpretador de linha de comando (requer configuração de PATH para arquivos baixados manualmente).

luaLua 5.4.3  Copyright (C) 1994-2021 Lua.org, PUC-Rio
>

Assim como feito para JavaScript e Python, esta seção apresentará os mesmos exemplos para fins de teste e comparações entre linguagens.

Como em Python, deve-se digitar o código em linguagem Lua após o sinal de maior (>).

Por exemplo, para se escrever no console, pode-se usar print() (documentação). Para escrever uma mensagem, escreva algo como print("Olá! Meu nome é Franco.") após o símbolo de maior e aperte enter. O interpretador escreverá Olá! Meu nome é Franco. e aguardará seu próximo comando.

luaLua 5.4.3  Copyright (C) 1994-2021 Lua.org, PUC-Rio
> print("Olá! Meu nome é Franco.")Olá! Meu nome é Franco.
>

Caso a resposta não apresente acentuação, provavelmente você está usando uma versão de Lua mais antiga, sem suporte a Unicode.

Doravante, toda vez que você ler um bloco de código em Lua e quiser executá-lo manualmente no interpretador, basta seguir os passos anteriores.

Para encerrar o interpretador, digite os.exit() seguindo de enter ou aperte Ctrl d. No Windows, o atalho pode ser Ctrl z seguido de enter.

Assim como Python, pode-se usar Lua em modo Read, Eval, Print, Loop (REPL). Em REPL, versões atuais de Lua podem interpretar expressões matemáticas e inspeções de variáveis digitando apenas a expressão. Em versões antigas, deve-se prefixar a expressão com um símbolo de igual (=). Por exemplo, = 1 + 1.

1 + 1

= 1 + 1

Da mesma forma, você poderia escrever diretamente uma cadeia de caracteres:

"Olá! Meu nome é Franco."

Entretanto, deve-se notar que, assim como em Python, os usos diretos anteriores são possíveis apenas no interpretador para uso interativo, ou seja, no estilo REPL. Eles são convenientes para inspecionar valores e variáveis, mas não são permitidos em programas. Caso queira fazer o mesmo em um arquivo com código-fonte (um script), você deve usar print() para escrever os resultados.

print(1 + 1)
print("Olá! Meu nome é Franco.")

Portanto, convém criar o hábito de usar print() quando quiser escrever no console. Por exemplo, crie um arquivo chamado script.lua (você pode escolher o nome que quiser) com o seguinte conteúdo:

print("Meu Primeiro Script em Lua")
print("Olá! Meu nome é Franco.")
print("O interpretador saber fazer contas.")
print("Veja só: ", 1 + 1)
print("Tchau!")

Para executar seu script, abra um interpretador de linha de comando (shell) no diretório em que ele foi criado e digite lua script.lua. O interpretador Lua executará o arquivo fornecido como parâmetro (o valor script.lua após lua) e mostrará os resultados de chamadas de print().

lua script.luaMeu Primeiro Script em Lua
Olá! Meu nome é Franco.
O interpretador saber fazer contas.
Veja só:        2
Tchau!

Caso o diretório atual no interpretador de linha de comando (shell) não seja o diretório do arquivo, você pode mudar para o diretório do arquivo ou pode escrever o caminho absoluto do arquivo. Exemplos de caminho absoluto poderiam ser C:\Users\Franco\Desktop\script.lua para um arquivo na área de trabalho do Windows em uma conta de usuário chamada Franco ou ~/Desktop/script.lua para um arquivo na área de trabalho do Linux.

Saber usar REPL e executar um arquivo com código Lua bastam para atividades de aprendizado. De forma geral, elas também são suficientes para a maioria das atividades para uso cotidiano ou profissional da linguagem de programação.

IDEs

As considerações feitas sobre o uso de IDE para Python valem para Lua. A conveniência, sobretudo importante para iniciantes, continua a ser um benefício do uso de IDEs.

A opção de executar código com um clique também vale para Lua. Em particular, procure pela opção de executar um projeto com um clique (normalmente sobre um ícone de triângulo (🢒) comumente usado como play, tocar ou reproduzir em eletroeletrônicos) ou com uma tecla (comumente F5). Além disso, lembre-se de atalhos para editores de texto, como Ctrl n para criar novos arquivos (Arquivo / Novo ou File / New em inglês) e Ctrl o (Arquivo / Abrir ou File / Open em inglês) para abrir arquivos existentes.

Embora existam menos IDEs para Lua que para Python, ZeroBrane Studio é uma excelente opção (embora sem os recursos para iniciantes que Thonny oferece para Python).

ZeroBrane Studio

A página oficial solicita uma doação antes de iniciar o download. Caso não se queira fazer uma, pode-se avançar para o download escolhendo-se a opção Take me to the download page this time (algo como "leve-me para a página de download desta vez").

Durante a instalação via arquivo executável, caso não se altere o diretório, os arquivos do IDE serão armazenados no mesmo diretório do arquivo de instalação. Caso se queira alterá-lo, escolha Browse... e, no novo painel, o diretório desejado para a instalação.

Também é possível alterar o idioma do IDE para Português, caso se deseje. Para isso, deve-se escolher a opção Edit / Preferences / Settings: User, que abrirá um arquivo chamado user.lua. ZeroBrane Studio utiliza um arquivo de configuração escrito na linguagem Lua para as configurações (para outras opções, pode-se consultar o manual).

Na última linha do arquivo, basta acrescentar:

language="pt-br"

Assim, por exemplo, o arquivo ficaria algo como:

--[[--
  Use this file to specify **User** preferences.
  Review [examples](+/usr/share/zbstudio/cfg/user-sample.lua) or check [online documentation](http://studio.zerobrane.com/documentation.html) for details.
--]]--

language="pt-br"

Salve o arquivo. Em seguida, após reiniciar o programa (isto é, fechá-lo e abri-lo em seqüência), o programa deverá estar em Português.

Para executar um arquivo com código-fonte no ZeroBrane Studio, pode-se usar o ícone de triângulo para iniciar o programa no depurador (atalho: F5) ou o ícone com dois triângulos (⏩, usando para avançar ou fast forward em eletroeletrônicos) para executar o programa sem o depurador (atalho: F6). No modo de depuração, pode-se apertar o ícone ou F5 novamente para executar o programa.

No primeiro uso de depurador, o Windows pode emitir um alerta de segurança. Caso deseje usar o depurador, deve-se permitir o acesso à rede local pelo ZeroBrane Studio.

O aviso refere-se à tentativa do IDE em usar a porta 8172 para comunicação entre IDE e programa executado durante a depuração.

Além disso, o IDE permite usar várias versões de Lua. É possível alterar a versão do interpretador Lua usada pelo ZeroBrane Studio em Projeto (Project), depois Interpretador de Lua (Lua Interpreter), depois Lua 5.3.

Decoda

Uma segunda opção de IDE para Lua chama-se Decoda. Antigamente, Decoda era um dos poucos IDEs para Lua com depurador integrado. Atualmente, ZeroBrane Studio é um IDE mais moderno e atualizado.

Decoda era uma opção paga, mas se tornou um projeto de código aberto por volta de 2013. O projeto não tem atualizações há alguns anos, mas continua uma alternativa válida para uso com Lua 5.1, especialmente caso o uso de Lua seja integrado em outro programa.

LuaEdit

Outra opção para potencial uso com Lua 5.1 é LuaEdit. Contudo, assim como Decoda, o projeto não é atualizado há alguns anos.

Outras Opções

Para outras opções de IDEs, pode-se instalar extensões em alguns programas.

• IntelliJ IDEA (a versão Community Edition é gratuita) com Lua ou EmmyLua;
• Visual Studio Code com vscode-lua;
• Atom com language-lua e dbg-lua.

Primeiros Passos para Começar a Programar em Lua

Os trechos de código a seguir ilustram alguns recursos da linguagem Lua. Neste momento, não é necessário entendê-los totalmente; o propósito é apresentar recursos e a sintaxe da linguagem.

Existem três formas de usar o código. Você pode:

1. Digitar (ou copiar e colar) o código diretamente em no interpretador da linguagem;
2. Escrever e executar o código no IDE de sua escolha;
3. Escrever o código usando um editor de texto e executar o arquivo criado no interpretador.

Os exemplos são os mesmos adotados para JavaScript. Logo, você poderá comparar linguagens, e observar semelhanças e diferenças entre elas.

Conhecendo Lua por Meio de Experimentação

1. Escrita de texto:

   print("Uma linha.")
   print("Outra linha.")
   print("Uma linha.\nOutra linha.")

2. Comentários (texto ignorado pelo interpretador; documentação):

   print("Interpretador processa") -- Interpretador ignora.

   --[[ <- Aqui começa o comentário.
   Ele pode ter várias linhas.
   Aqui ele termina -> ]]--

   --[[ Ele também pode começar e terminar na mesma linha. ]]--

   -- Contudo, para isso, é mais fácil usar este estilo de comentário.

3. Cálculos matemáticos:

   • Soma, subtração, multiplicação e divisão (documentação):

     print(1 + 1)
     print(2 - 2)
     print(3 * 3)
     print(4 / 4) -- O que ocorre caso se tente dividir por 0? Faça o teste!

   • Expressões matemáticas:

     print(1 + 2 - 3 + (4 * 5) / 6)

   • Potenciação (documentação):

     print(5 ^ 2)

   • Raiz quadrada (documentação: math.sqrt()):

     print(math.sqrt(25))

   • Operações trigonométricas, como seno (documentação: math.sin e math.pi):

     print(math.sin(math.pi / 2.0)) -- Seno.

4. Comparações (True significa verdadeiro; False significa falso):

   • Igualdade (documentação):

     print(1 == 2) -- Igual: os dois iguais são necessários!
     print(1 ~= 2) -- Diferente.

     print("Franco" == "Franco")
     print("Franco" ~= "Franco")
     print("Franco" ~= "Seu Nome")
     -- Lua considera que letras minúsculas são diferentes de maiúsculas (e vice-versa).
     print("F" == "f")
     print("F" ~= "f")
     print("Franco" == "franco")
     print("Franco" ~= "franco")

   • Outras comparações (documentação):

     print(1 < 2) -- Menor.
     print(1 > 2) -- Maior.
     print(1 <= 2) -- Menor ou igual.
     print(1 >= 2) -- Maior ou igual.

5. Variáveis e atribuição (documentação):

   Variáveis são como caixinhas que armazenam valores colocados dentro delas. Efetiva-se um armazenamento usando o operador de atribuição, que é um único igual (=) em Lua.

   O uso de local define uma variável local ao invés de uma variável global. Caso se omita local, a variável será global.

   local x = 123
   print(x)

   local resultado = 123.456 + 987.654
   print(resultado)

   Deve-se notar que a declaração de variáveis pode ser feita uma única vez por nome escolhido. Entretanto, pode-se mudar seu valor quantas vezes forem necessárias.

   local nome = "Franco"
   print(nome)
   nome = "Franco Garcia"
   print(nome)

   local variaveis_podem_variar = "Franco"
   print(variaveis_podem_variar)
   variaveis_podem_variar = "Seu Nome"
   print(variaveis_podem_variar)
   variaveis_podem_variar = "Outro Nome"
   print(variaveis_podem_variar)

   local valor_logico = True
   print(valor_logico)
   valor_logico = False
   print(valor_logico)
   valor_logico = (1 + 1 == 2)

6. Constantes (documentação):

   Constantes em Lua estão disponíveis desde a versão 5.4 da linguagem.

   local PI <const> = 3.14159
   print(PI)

   local E <const> = 2.71828
   print(E)
   E = 0 -- Erro; o valor de uma constante é inalterável após definido.

7. Erros:

   print(Ooops!) -- Texto deve estar entre aspas duplas, simples, ou pares de colchetes de cada lado.
   pri("Nome incorreto para print")
   print(1 / 0)
   print(0 / 0)

8. Cadeias de caracteres (strings) para palavras e texto (documentação):

   print("Ok, cadeia de caracteres válida")
   print('Ok, outra cadeia de caracteres válida')
   print([[Ok, também é uma cadeia de caracteres válida]])

   print("Para 'misturar' aspas, use diferentes das externas.")
   print("Caso contrário, você precisa escapá-las com uma contrabarra, assim: \". A contrabarra é necessária.")

9. Operações lógicas (documentação):

   print(true and true) -- Operação lógica "e" ("and").
   print(true or false) -- Operação lógica "ou" ("or").
   print(not true) -- Operação lógica "não" ("not").

10. Condições (documentação):

    local navegador = "Firefox"
    if (navegador == "Firefox") then
        print("Mozilla Firefox.")
    end

    local meu_navegador = "Seu Navegador"
    if (meu_navegador == "Firefox") then
        print("Você usa um navegador da Mozilla.")
    else
        print("Você usa outro navegador.")
    end

    local eu_uso = "X"
    eu_uso = eu_uso:lower()
    if (eu_uso == "firefox") then
        print("Você usa um navegador da Mozilla.")
    elseif ((eu_uso == "chrome") or (eu_uso == "chromium")) then
        print("Você usa um navegador do Google.")
    elseif (eu_uso == "edge") then
        print("Você usa um navegador da Microsoft.")
    elseif (eu_uso == "safari") then
        print("Você usa um navegador da Apple.")
    elseif (eu_uso == "internet explorer") then
        print("Você deveria usar um navegador mais moderno...")
    else
        print("Você usa outro navegador.")
    end

11. Repetições ou laços (documentação: while e repeat), e for):

    for i = 0, 5, 1 do
        print(i)
    end

    j = 0
    while (j < 5) do
        print(j)
        j = j + 1
    end

    Lua possui o comando repeat... until ao invés de do... while. Para se obter um comando do... while equivalente, basta negar a condição usando not.

    k = 0
    repeat
        print(k)
        k = k + 1
    until (k >= 5)

12. Funções (documentação):

    function minha_funcao(x, y)
        local resultado = x + y
        return resultado
    end
    
    -- Uma função é um bloco de código que realiza um processamento arbitrário
    -- conforme definido pela programadora ou pelo programador.
    -- Após a definição, pode-se executar a função quando se quiser, por meio
    -- de uma chamada de função.
    local z = minha_funcao(12, -34) -- Este é um exemplo de uma chamada de função.
    print(z)
    print(minha_funcao(1, 2)) -- Este é outro.

13. Tipos de dados (documentação):

    local numero_inteiro = 1
    local outro_numero_inteiro = -1
    local numero_real = 1.23
    local valor_logico = true -- ou false; só pode ser true ou false.
    local cadeia_caracteres = "Texto aqui. Quebras de linha usam\nou seja, isto estará\n na terceira linha."

14. Entrada (documentação: io.read() e io.write(), e string.format()):

    -- Quando se solicitar a entrada de um valor, escreva um e aperte `enter`.
    io.write("Qual é o seu nome? ")
    local seu_nome = io.read("*line")
    io.write("Quantos anos você tem? ")
    local sua_idade = io.read("*number", "*line") -- Apenas number bastaria, mas adicionar line depois evita
                                               -- deixar caracteres extras para próximas leituras.
    print(seu_nome)
    print(sua_idade)
    -- O operador .. faz uma operação -- chamada concatenação,
    -- que combina a segunda cadeira após a primeira.
    print("Olá, " .. seu_nome .. "!")
    print(string.format("Você tem %d anos.", sua_idade))

Parabéns! Você Já Pode Escrever Qualquer Programa em Lua

Não acredita? Você pode encontrar a explicação na introdução à linguagem JavaScript.

Em resumo, aprender a sintaxe de uma linguagem não é suficiente para resolver problemas com ela. O aprendizado de lógica de programação e o desenvolvimento de habilidades de pensamento computacional são muito mais importantes que a sintaxe. De fato, quando se tem dúvidas sobre a sintaxe, basta consultar a documentação. Não é preciso decorá-la.

Após aprender uma primeira linguagem de programação, aprender outras linguagens (que adotem paradigmas semelhantes aos da primeira) é relativamente simples. Para constatar a afirmação, pode-se abrir uma nova janela em seu navegador e deixá-la lado a lado com esta. Em seguida, pode-se comparar os blocos de código escritos em Lua (nesta janela) e em Python (na segunda janela).

Caso se deseje fazer comparações entre mais linguagens de programação, pode-se escolher:

• C;
• C++;
• GDScript (Godot Engine);
• Java;
• JavaScript;
• Lua;
• LISP;
• Python;
• Prolog;
• SQL (SQLite).

Próximos Passos

Com o ambiente de desenvolvimento configurado, você pode continuar sua jornada de desenvolvimento de sistemas.

Para evitar repetições, recomendo a leitura da página sobre configurações de ambiente para JavaScript. Mesmo que você não tenha interesse na linguagem, muitas discussões são relevantes para quaisquer linguagens de programação. Além disso, você entenderá uma forma de criar páginas para a Internet e poderá criar conteúdo para seu navegador.

Até GDScript (para Godot Engine), os tópicos descrevem configurações de ambientes de desenvolvimento para algumas linguagens de programação. Após GDScript, o foco torna-se conceitos básicos para o aprendizado de programação.