Lua

Lua
Logotipo da lua
Dados básicos
Paradigmas :	Linguagem de script , imperativo , funcional
Ano de publicação:	1993
Designer:	Roberto Ierusalimschy
Desenvolvedor:	Roberto Ierusalimschy, Waldemar Celes, Luiz Henrique de Figueiredo
Versão atual	5.4.3   (29 de março de 2021)
Digitando :	dinamicamente fraco ( tipagem fraca )
Implementações importantes :	Lua , LuaJIT, LLVM-Lua, LuaCLR
Dialetos:	Metalua, ocioso, GSL Shell
Influenciado por:	C ++ , CLU , Modula , Scheme , SNOBOL
Afetado:	Falcon , GameMonkey , Io , JavaScript , Julia , MiniD , MoonScript , Red , Ruby , Squirrel
Sistema operacional :	plataforma independente
Licença :	Licença MIT
www.lua.org

Lua ( português para lua ) é uma linguagem de script imperativa e extensível para integração em programas a fim de ser capaz de desenvolvê-los e mantê-los com mais facilidade. Uma das características especiais de Lua é o pequeno tamanho do interpretador do script compilado .

Os programas Lua são, em sua maioria , independentes de plataforma e são traduzidos em bytecode antes de serem executados . Embora Lua também possa ser usada para escrever programas independentes, ela foi projetada principalmente como uma linguagem de script embarcada para outros programas. Nesse aspecto, é comparável ao Tcl . As vantagens da Lua são o pequeno tamanho de 120 kB, a capacidade de expansão e a alta velocidade em comparação com outras linguagens de script.

O interpretador Lua é um C - biblioteca são abordados, que é também uma API para o ambiente de execução inclui o intérprete para chamadas a partir do programa C. Usando a API, diferentes partes do programa podem ser escritas em C (ou C ++) e Lua, enquanto variáveis ​​e funções permanecem acessíveis em ambas as direções (ou seja, uma função em Lua pode chamar uma função em C / C ++ e vice-versa versa).

Também existe um compilador JIT gratuito chamado LuaJIT que suporta a revisão 5.1 da linguagem.

Lua está em ANSI-C implementa e suporta programação imperativa e funcional . No entanto, se você mesmo implementar objetos usando meta - tabelas, a programação orientada a objetos também é possível.

história

Lua foi desenvolvido em 1993 por Roberto Ierusalimschy, Luiz Henrique de Figueiredo e Waldemar Celes na Gráficos Grupo de Tecnologia Informática da a Pontifícia Universidade Católica do Rio de Janeiro no Brasil . Lua é um software livre e foi publicado até a versão 4 sob sua própria licença BSD , a partir da versão 5 sob a licença MIT .

usar

Lua pode ser usada para escrever programas independentes e também servir como uma linguagem embarcada.

Para obter componentes individuais de um jogo de computador , como Por exemplo, para separar arquivos de configuração ou a IA de personagens controlados por computador ou oponentes do motor de jogo , Lua é frequentemente usada no desenvolvimento de jogos de computador. Isso torna o mecanismo de jogo normalmente desenvolvido de forma cara mais flexível e permite a reutilização associada com menos esforço, razão pela qual Lua é usada na área de jogos proprietários .

Alguns particularmente dinâmico e azulejos - gerenciador de janelas para usar Lua para configuração e controle, incluindo incrível e Ion3 .

sintaxe

Tipos de dados

Além dos tipos de dados nil , boolean , number (com os subtipos internos integer e float ), string , function, userdata e thread , Lua reconhece table como o único tipo de dado estruturado.

Uma tabela é um campo de dados associativo , ou seja, uma coleção de pares de dados-chave. A chave (índice) pode ter qualquer tipo de dados (exceto nulo). Também é feita uma distinção entre a tecla numérica 1 e a tecla string "1". Em contraste com as linguagens semelhantes a C, a indexação de tabelas começa com 1.

As tabelas podem ser criadas das seguintes maneiras:

T = {}                        -- Erzeugt eine leere Tabelle und weist sie der Variablen mit dem Namen T zu.
T = {"ja", "nein", "?"}       -- Eine Tabelle mit 3 Elementen, wobei T[1] == "ja", T[2] == "nein" und T[3] == "?".
T = {[1] = "ja", [2] = "nein", [3] = "?"} -- Wie Zeile vorher, nur mit expliziter Indizierung.
T = {[-900] = 3, [900] = 4}  -- Tabelle mit 2 Elementen, aber unregelmäßigen Indizes.
T = {x=5, y=10}              -- Typisches assoziatives Datenfeld mit T["x"], T["y"] (auch als T.x, T.y zugreifbar)
T = {x=5, y=10; "ja", "nein"} -- Gemischte Tabelle mit T.x, T.y, T[1], T[2]
T = {Nachricht = "wahl", {"ja", "nein", "?"}} -- Tabellen können weitere Tabellen enthalten.

atribuições

a = 5
b = "hi"
local a = a
-- Einfache Zuweisungen. Variablen sind nicht typisiert und können verschiedene Datentypen haben.
-- Lokale Variablen (definiert mit "local") sind auf den aktuellen Namensbereich beschränkt.
a, b, c = 1, 2, 3 -- Mehrfachzuweisungen sind erlaubt.
a, b = b, a -- Wertetausch: Anweisungen werden von rechts nach links ausgewertet.
a, b = 4, 5, "6" -- Überflüssige Werte (Bsp: "6") werden ausgewertet, aber verworfen.
a, b = "da" -- Fehlende Werte auf der rechten Seite werden mit "nil" ersetzt.
a = nil -- Zerstört a. Der Speicherbereich von a wird vom Garbage-Collector freigegeben.
a = z -- Falls z nicht definiert ist, wird "nil" zugewiesen und somit a freigegeben.
a = "3" + "2" -- Der Operator + erwartet Zahlen, die Zeichenketten werden also
             -- in Zahlen konvertiert, also erfolgt hier die Zuweisung a = 5.
a = 3 .. 2 -- Der Verbindungsoperator erwartet Zeichenketten, die Zahlen werden
          -- konvertiert - a = "32".
local a <const> = 5 -- lexikalische (lokale) Konstanten wurden in Lua 5.4 eingeführt
local f <close> = io.open(file) -- ebenfalls ab 5.4: to-close-Variablen mit ähnlicher Semantik
                                -- wie Pythons Context Manager (with ...)

Funções

As funções podem ser criadas com a palavra-chave function. As funções não têm um número fixo de parâmetros e valores de retorno.

function probe(zahl1, zahl2, text, tabelle)
    zahl3 = zahl1 + zahl2
    zahl4 = zahl1 - zahl2

    print(text)

    if tabelle ~= nil then
        print(tabelle.eintrag)
    end

    return zahl3,zahl4
end

probe(10, 20, "Hallo ", {eintrag = "Welt"}) -- erlaubter Funktionsaufruf

x,y = probe(10,20) -- ebenfalls erlaubter Aufruf, text und tabelle sind nil.

Quando a função é chamada, nem todas as variáveis ​​precisam ser transferidas. Os parâmetros ausentes têm automaticamente o valor zero nil . O mesmo vale para valores de retorno. Isso torna mais fácil implementar sobrecargas de funções, mas a incidência de erros de tempo de execução aumenta.

Palavras-chave reservadas

and break do else elseif end false for function goto if in
local nil not or repeat return then true until while

A palavra-chave nilrepresenta (ao lado de false ) para false e geralmente para variáveis ​​não inicializadas ou valores que não podem ser interpretados.

Código de amostra

O programa hello world clássico é parecido com este:

print("Hallo Welt!")

Os comentários podem ser de uma ou várias linhas:

-- Ein Kommentar in Lua beginnt mit zwei Bindestrichen und geht bis zum Ende der Zeile.
--[[Kommentare können auch über mehrere
     Zeilen ausgeweitet werden, sodass die Dokumentation
     des Quellcodes leichter fällt.]]

Exemplo de recursão (cálculo do fatorial ):

function factorial(n)
    if n == 0 then
        return 1
    end

    return n * factorial(n - 1)
end

Com os operadores de curto-circuito "e" e "ou" a função pode ser escrita de uma forma mais curta (isto corresponde ao operador de seleção  ?: De C e linguagens relacionadas):

function factorial(n)
    return n == 0 and 1 or n * factorial(n - 1)
end

Funções são consideradas objetos de primeira classe em Lua . Isso significa, em particular, que as funções podem ser geradas dinamicamente durante o tempo de execução e as variáveis ​​(também existentes) podem ser atribuídas. O exemplo a seguir mostra como a variável print(que aponta para uma função padrão da biblioteca Lua) é substituída por outra função:

do
    local oldprint = print     -- aktuelle (globale) print-Funktion über oldprint zugreifbar machen
    function print(s)          -- Neue (globale) Definition von print, ...
        oldprint("I say: " .. s) -- ... die die alte print-Funktion aufruft.
    end
end

Os comandos em Lua podem terminar com um ponto e vírgula . Se vários comandos estiverem em uma linha, isso torna o código mais fácil de ler.

A sintaxe é baseada na do Pascal , o que torna mais fácil para iniciantes começarem a usar Lua. Em contraste com as linguagens derivadas de Pascal, no entanto, Lua usa “==” e não “=” como um operador de comparação, “=” como um operador de atribuição (em vez de “: =” em Pascal) e “~ =” para diferente (em vez de “<>").

Módulos

Lua pode ser expandida conforme necessário com módulos definidos pelo usuário. O gerenciador de pacotes LuaRocks, escrito em Lua, está disponível para gerenciá-los .

Uma lista de módulos Lua comuns:

literatura

• Roberto Ierusalimschy: Programming in Lua , 4ª edição, Open Source Press, 2016, ISBN 978-8-59037-986-7 .
• Roberto Ierusalimschy, LH Figueiredo, W. Celes: Lua 5.1 Reference Manual , agosto de 2006, ISBN 85-903798-3-3 .
• Kurt Jung, Aaron Brown: Beginning Lua Programming , Wrox, 2007, ISBN 0-470-06917-1 .
• Claus Kühnel, Daniel Zwirner: Lua: Use of Lua in Embedded Systems , 2ª edição, Script Verlag Kühnel, 2012, ISBN 978-3-90785-715-1 .
• David Young: Learning Game AI Programming with Lua , Packt Publishing, 2014, ISBN 1-783-28133-2 .

Links da web

• Lua.org - site oficial (inglês e português)
• Lua não oficial FAQ
• LuaRocks - gerenciador de pacotes e repositório
• Wiki Usuários Lua
• Lua incrível no GitHub
• Aprenda Lua em 15 minutos
• Script rápido, leve e integrado com Lua por Jan Bornholdt, Wedel University of Applied Sciences

Fontes e notas