Lua (linguagem de programação)
![](http://upload.wikimedia.org/wikipedia/commons/thumb/4/4a/Disambig_grey.svg/20px-Disambig_grey.svg.png)
Lua | |
---|---|
![]() | |
Paradigma | Multiparadigma |
Surgido em | 1993 (30–31 anos) |
Última versão | 5.4.7 (25 de junho de 2024; há 2 meses[1]) |
Criado por | Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes |
Estilo de tipagem |
|
Principais implementações |
|
Dialetos: | Metalua |
Influenciada por |
|
Influenciou |
|
Licença | MIT |
Extensão do arquivo | .lua |
Página oficial | www |
Lua é uma linguagem de programação interpretada, de script em alto nível, com tipagem dinâmica e multiparadigma, reflexiva e leve, projetada por Tecgraf da PUC-Rio em 1993 para expandir aplicações em geral, de forma extensível (que une partes de um programa feitas em mais de uma linguagem), para prototipagem e para ser embarcada em softwares complexos, como jogos.[3] Assemelha-se com Python, Ruby e Icon, entre outras.[4]
Lua foi criada por um time de desenvolvedores do Tecgraf da PUC-Rio, a princípio, para ser usada em um projeto da Petrobras. Devido à sua eficiência, clareza e facilidade de aprendizado, passou a ser usada em diversos ramos da programação, como no desenvolvimento de jogos (Blizzard Entertainment, por exemplo, usou a linguagem no jogo World of Warcraft), controle de robôs, processamento de texto, etc. Também é frequentemente usada como uma linguagem de propósito geral.
Lua combina programação procedural com poderosas construções para descrição de dados, baseadas em tabelas associativas e semântica extensível. É tipada dinamicamente, interpretada a partir de bytecodes, e tem gerenciamento automático de memória com coleta de lixo. Essas características fazem de Lua uma linguagem ideal para configuração, automação (scripting) e prototipagem rápida.
História
Lua foi criada em 1993 por Roberto Ierusalimschy, Luiz Henrique de Figueiredo e Waldemar Celes, membros do Computer Graphics Technology Group na PUC-Rio, a Pontifícia Universidade Católica do Rio de Janeiro, no Brasil.[5] Versões de Lua antes da versão 5.0 foram liberadas sob uma licença similar à licença BSD. A partir da versão 5.0, Lua foi licenciada sob a licença MIT.
Alguns de seus parentes mais próximos são o Icon, por sua concepção, e Python, por sua facilidade de utilização por não programadores. Em um artigo publicado no Dr. Dobb's Journal, os criadores de Lua também afirmam que Lisp e Scheme foram uma grande influência na decisão de desenvolver a tabela como a principal estrutura de dados de Lua. Lua tem sido usada em várias aplicações, tanto comerciais como não comerciais.
O primeiro projeto utilizando a linguagem em jogos foi em 1997 quando a LucasArts a utilizou como linguagem de script no jogo Grim Fandango.[3]
Em 2008 nasceu uma das engines mais famosas de Lua (Corona SDK)
Em 2009 nasceu o Love2D, uma engine para jogos 2d
Características
Lua é normalmente descrita como uma linguagem de múltiplos paradigmas, oferecendo um pequeno conjunto de características gerais que podem ser estendidas para encaixar diferentes tipos de problemas, em vez de fornecer uma especificação mais complexa e rígida para combinar com um único paradigma. Lua, por exemplo, não contém apoio explícito à herança, mas permite que ela seja executada com relativa facilidade com metatables. Do mesmo modo, Lua permite que programadores quando implementam nomes, classes, e outras funções, empreguem poderosas técnicas de programação funcional e completos escopos lexicais.
Lua é uma linguagem que suporta apenas um pequeno número de estruturas, tais como dados atômicos, valores booleanos, números (dupla precisão em ponto flutuante por padrão), e strings. As estruturas de dados comuns, tais como matrizes, conjuntos, tabelas, listas, e registros podem ser representados por meio de Lua. Lua não foi construída com suporte para programação orientada a objeto.
A Linguagem
Esta seção descreve o vocabulário, aspectos sintáticos e semânticos de Lua. Em outras palavras, esta seção descreve quais itens de vocabulário são válidos, como combiná-los e o que significam. A estrutura da linguagem será explicada usando a notação BNF estendida usual, onde {a} representa zero ou mais a, e [a] representa um a opcional. Os não terminais são exibidos como não terminais, as palavras-chave são exibidas como kword e outros símbolos de terminal são exibidos como "=". A sintaxe Lua completa pode ser encontrada em §8 no final deste manual.
Convenções Léxicas[6]
Em Lua, um nome (também chamado de identificador) pode ser qualquer string de letras, números e sublinhados que não comece com um número. Esta definição é consistente com a definição de nomes na maioria dos idiomas. (A definição da letra depende do idioma (local): o idioma atual considera qualquer caractere da letra a ser usado como um identificador.) Os identificadores são usados para nomear variáveis e campos de tabela.
and | break | do | else | elseif | |
---|---|---|---|---|---|
end | false | for | function | if | |
in | local | nil | not | or | |
repeat | return | then | true | until | while |
Lua é uma linguagem que diferencia maiúsculas de minúsculas: and
é uma palavra reservada, mas And
e AND
são dois nomes válidos diferentes. Por convenção, nomes que começam com sublinhado e letras maiúsculas (como _VERSION
) são reservados para variáveis globais internas usadas por Lua.
+ | - | * | / | % | ^ | # |
---|---|---|---|---|---|---|
== | ~= | <= | >= | < | > | = |
( | ) | { | } | [ | ] | |
; | : | , | . | .. | ... |
Sintaxe e exemplos
O Programa Olá Mundo pode ser escrito da seguinte forma:
print("Olá, Mundo!")
Algoritmo de Trabb Pardo-Knuth
![](http://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Magnifying_glass_01.svg/17px-Magnifying_glass_01.svg.png)
local function f(t) return math.sqrt(math.abs(t)) + 5 * t ^ 3 end local a = {} for i = 1, 11 do a[i] = io.read("*number") end for i = #a, 1, -1 do local y = f(a[i]) print(i - 1, y > 400 and "TOO LARGE" or y) end
Funções
A função fatorial recursiva:
function fact(n) if n == 0 then return 1 else return n * fact(n - 1) end end
O cálculo dos n primeiros números perfeitos:
function perfeitos(n) cont=0 x=0 print("Os números perfeitos são:") repeat x=x+1 soma=0 for i=1,(x-1) do if math.mod(x,i)==0 then soma=soma+i; end end if soma == x then print(x) cont = cont+1 end until cont==n print("Pressione qualquer tecla para finalizar...") end
O tratamento das funções como variáveis de primeira classe é mostrado no exemplo a seguir, onde o comportamento da função “print” é modificado:
do local oldprint = print -- Grava a variável “print” em “oldprint” print = function(s) -- Redefine a função “print” if s == "foo" then oldprint("bar") else oldprint(s) end end end
Qualquer chamada da função “print” agora será executada através da nova função, e graças ao escopo léxico de Lua, a função “print” antiga só será acessível pelo nova.
Lua também suporta funções closure, como demonstrado abaixo:
function makeaddfunc(x) -- Retorna uma nova função que adiciona x ao argumento return function(y) return x + y end end plustwo = makeaddfunc(2) print(plustwo(5)) -- Prints 7
Um novo “closure” é criado para a variável x cada vez que a função “makeaddfunc” é chamada, de modo que a função anônima a ser retornada sempre irá acessar seu próprio parâmetro x. O “closure” é gerenciado pelo coletor de lixo (garbage collector) da linguagem, tal como qualquer outro objeto.
As funções em Lua são apenas uma categoria de variáveis. Elas podem ser definidas, também, como se fosse uma:
local foo = function(a,b,c) print('variable "foo"') end
Ou podem estar dentro de tabelas:
local myTable = {'item 1', function() print('table item 2') end, 3}
Estruturas de repetição
O programa Lua fornece 4 tipos diferentes de loops: while, repeat (similar ao do while de outras linguagens), for e o loop genérico. Suas respectivas sintaxes são demonstradas abaixo:
while condição do -- Comandos end
repeat -- Comandos until condição
for i = início, fim, passo do -- O passo pode ser positivo ou negativo -- Comandos -- Exemplo: print(i) end
for key, value in next, some_table do -- Comandos end
Em relação ao laço genérico, ele irá atuar sobre cada par de dados presente na tabela. Esse tipo de laço é semelhante ao que encontramos em Python.
A seguir, um exemplo simples de utilização:
local info = { John = 10, Alex = 32 } -- Declaração de uma tabela com pares chave/valor for key, value in next, info do -- “key“ e “value” serão as variáveis utilizadas -- elas armazenarão a chave da tabela (o nome) -- e o valor dessa chave (a idade) print("Name: ", key) print("Age: ", value) end -- Saída: -- Name: John -- Age: 10 -- Name: Alex -- Age: 32
Tabelas
As tabelas são as estruturas de dados mais importantes (e, por concepção, a única estrutura de dados complexas) em Lua, e são a base de todos os tipos de dados possíveis na linguagem. Por meio da utilização de tabelas podemos simular vetores, matrizes, estruturas, objetos, etc.
A tabela é um conjunto de chaves e pares de dados também conhecido como hashed heterogeneous associative array', onde os dados são referenciados por chave. A chave (índice) pode ser de qualquer tipo de dado exceto nulo. Um inteiro com chave valor 1 é considerada distinta da chave de uma string "1".
As tabelas são criadas usando a seguinte sintaxe: {}
a_table = {} -- Cria uma nova tabela vazia
Tabelas sempre são passadas por referência:
a_table = {x = 10} -- Cria uma nova tabela, com uma entrada associada. Onde o caractere "x" recebe o valor numérico 10. print(a_table["x"]) -- Escreve o valor da tabela a_table índice "x", que neste caso tem o valor numérico 10 b_table = a_table a_table["x"] = 20 -- O valor da tabela a_table índice "x", é trocado para 20 print(a_table["x"]) -- Escreve o valor de a_table índice "x", que é igual a 20 print(b_table["x"]) -- Escreve o mesmo valor que a_table índice "x", porque a_table e b_table ambos referem-se à mesma tabela.
Tabelas como vetor
Ao se criar uma tabela, os dados inseridos nela ganham automaticamente um índice numérico para identificá-los. Porém, ao contrário de outras linguagens de programação, o primeiro índice recebe o valor de 1, e não 0.
A seguir, um exemplo de como é possível simular a utilização de um vetor utilizando uma tabela em Lua:
array = { "a", "b", "c", "d" } -- Os índices são atribuídos automaticamente. print(array[2]) -- Imprime "b". A indexação automática em Lua começa em 1. print(#array) -- Imprime 4. # é o operador de tamanho para tables e strings. array[0] = "z" -- 0 é uma posição aceita print(#array) -- Ainda imprime 4, como as matrizes Lua são baseadas em 1.
Tabelas como estrutura
As tabelas são frequentemente utilizadas como estruturas, utilizando strings como chaves, porque este tipo de uso é muito comum, e Lua apresenta uma sintaxe especial para acessar esses tipos de domínios. Exemplo:
point = { x = 10, y = 20 } -- Cria uma nova tabela print(point["x"]) -- Imprime 10 print(point.x) -- Faz a mesma coisa que a linha acima
Exemplo de um vetor de estruturas:
function Point(x, y) -- Construtor para objetos "Point" return { x = x, y = y } -- Cria e retorna um objeto (tabela) end array = { Point(10, 20), Point(30, 40), Point(50, 60) } -- Cria array de objetos "Point" print(array[2].y) -- Imprime 40
Tabela como matriz
Exemplo de tabela simulando uma simples matriz:
matriz = { {1, 2, 3, 4}, {5, 6, 7, 8} } print(matriz[1][3]) -- Saída: 3 print(matriz[2][4]) -- Saída: 8
Tabelas e orientação a objetos
Apesar da Lua não possuir os conceitos de orientação a objetos, é possível utilizar esse paradigma através de dois recursos da linguagem: first-class functions e tabelas. Ao colocar funções e dados relacionados em uma tabela, criamos um objeto.
O conceito de herança também pode ser implementado utilizando metatables, pedindo para o objeto buscar métodos/atributos não existentes em objetos pais.
A seguir, como exemplo, será criado um objeto vetor, utilizando a sintaxe facilitada que a linguagem nos oferece para a orientação a objetos:
local Vetor = { } -- Criação da classe “Vetor” Vetor.__index = Vetor function Vetor:new(x, y, z) -- Construtor return setmetatable({x = x, y = y, z = z}, Vetor) end function Vetor:magnitude() -- Referenciamos atributos do próprio objeto utilizando “self” return math.sqrt(self.x^2 + self.y^2 + self.z^2) end local vec = Vetor:new(0, 1, 0) -- Criação de um objeto da classe Vetor print(vec:magnitude()) -- Chamada de um método (Saída: 1) print(vec.x) -- Acessando um atributo (Saída: 0)
Um outro exemplo de construção de classe e programação orientada a objetos pode ser observada abaixo.
local Vetor = { } do --Um novo bloco Vetor.init = function(x, y, z) --Construtor self = setmetatable({ x = x, y = y, z = z }, {__index=Vetor}) return self end function Vetor:magnitude() --Função do objeto return math.sqrt(self.x^2 + self.y^2 + self.z^2) end end local vec = Vetor.init(0, 1, 0) -- Criação de um objeto da classe Vetor print(vec:magnitude()) -- Chamada de um método (Saída: 1) print(vec.x) -- Acessando um atributo (Saída: 0)
Lua consegue ser flexível, intuitiva e dinâmica o suficiente para suportar quase qualquer conceito existente nativamente em outras linguagens por meio das metatables, mesmo que o conceito não esteja descrito nativamente na linguagem.
Metatables
Uma característica essencial de Lua é a semântica Extensível, e o conceito de “metatables” permite que as tabelas Lua sejam personalizadas em poderosas e exclusivas formas. O exemplo a seguir mostra uma tabela “infinita”. Para qualquer valor “n”, “fibs [n]” dará o enésimo número Fibonacci usando programação dinâmica.
fibs = { 1, 1 } -- Valores iniciais de fibs[1] e fibs[2]. meta_table = setmetatable(fibs, { __index = function(name, n) -- __index é uma função predefinida, que será chamada se a chave “n” não existir name[n] = name[n - 1] + name[n - 2] -- Calcula e grava fibs[n]. return name[n] end }) print (meta_table[3]) -- Saída: 2
Projetos que utilizam Lua
Em 2013, a Wikimedia Foundation começou a utilizar a linguagem nas predefinições.[7]
Projetos
- Adobe Photoshop Lightroom[8]
- Celestia
- Cheat Engine
- ClanLib
- CryEngine 3
- Corona SDK
- Damn Small Linux
- Ginga
- Kepler (software)
- lighttpd
- Liquid Feedback
- MinGW
- Monotone
- Nmap
- PlayStation Home
Jogos
Exemplos de empresas que desenvolveram jogos usando a linguagem Lua: LucasArts, Croteam, BioWare, Microsoft, Relic Entertainment, Absolute Studios, Monkeystone Games,[3] Blizzard,[7] SNKPlaymore, Facepunch Studios, KOG.
- Angry Birds[9]
- Baldur's Gate[3]
- The Battle for Wesnoth[10]
- Civilization V
- Counter-Strike Online / Counter-Strike Nexon: Zombies
- Dark Souls II
- Escape from Monkey Island[3]
- Fable II
- Far Cry[3]
- FlyFF
- Freeciv
- Freelancer
- Garry's Mod
- Grand Chase
- Grim Fandango[3]
- Impossible Creatures[3]
- Lego Universe
- MapleStory
- MDK2
- Monopoly Tycoon
- Multi Theft Auto
- Psychonauts[3]
- Ragnarok Online
- Project zomboid
- Roblox
- Street Fighter IV [8]
- The King of Fighters XIII
- OpenTibia [11]
- Transformice
- The Talos Principle
- World of Warcraft[7][9]
Ver também
Referências
- ↑ «Lua: version history». www.lua.org (em inglês). 25 de junho de 2024. Consultado em 26 de julho de 2024
- ↑ Ierusalimschy, Roberto (2009). «Uma Introdução à Programação em Lua» (PDF). PUC Rio. Consultado em 28 de agosto de 2018
- ↑ a b c d e f g h i Waldemar Celes; Luiz Henrique de Figueiredo, Roberto Ierusalimschy (2004). «A Linguagem Lua e suas Aplicações em Jogos» (pdf). Consultado em 15 de Março de 2013 A referência emprega parâmetros obsoletos
|coautores=
(ajuda) - ↑ André Rosa (30 de Maio de 2005). «Introdução a LUA, uma poderosa linguagem de programação». Consultado em 14 de Janeiro de 2016
- ↑ «Linguagem Lua, criada no Brasil, tem primeiro livro em português sobre programação». O Globo. 7 de Julho de 2015. Consultado em 14 de Janeiro de 2016
- ↑ «Manual de Referência de Lua 5.1». webserver2.tecgraf.puc-rio.br. Consultado em 13 de setembro de 2020
- ↑ a b c «New Lua templates bring faster, more flexible pages to your wiki». Wikimedia (em inglês). 11 de março de 2013. Consultado em 5 de Maio de 2013
- ↑ a b «O que Street Fighter IV, Photoshop, o Angry Birds e a Petrobras tem em comum?». petrobras.com.br. Consultado em 18 de agosto de 2021
- ↑ a b «A Linguagem de Programação». lua.org. Consultado em 18 de agosto de 2021
- ↑ «The Battle for Wesnoth Open Source Project on Ohloh». Consultado em 29 de Abril de 2014
- ↑ «Where lua is used» (em inglês). Consultado em 24 de Agosto de 2021
Bibliografia
- Ierusalimschy, Roberto; Figueiredo, Luiz Henrique de; Celes, Waldemar (2006). Lua 5.1 Reference Manual. Rio de Janeiro: Lua.org. 103 páginas. ISBN 85-903798-3-3 !CS1 manut: Nomes múltiplos: lista de autores (link)
- Ierusalimschy, Roberto (2006). Programming in Lua. Rio de Janeiro: Lua.org. 252 páginas. ISBN 85-903798-2-5
- Jung, Kurt; Brown, Aaron (2007). Beginning Lua Programming. Indianapolis: Wiley Publishing. 644 páginas. ISBN 978-0-470-06917-2 !CS1 manut: Nomes múltiplos: lista de autores (link)
Ligações externas
![](http://upload.wikimedia.org/wikipedia/commons/thumb/4/4a/Commons-logo.svg/22px-Commons-logo.svg.png)
![Wikilivros](http://upload.wikimedia.org/wikipedia/commons/thumb/a/a6/MediaWiki-2020-icon.svg/44px-MediaWiki-2020-icon.svg.png)
O MediaWiki tem documentação sobre Lua
- Sítio oficial (em inglês e português)
- Lua no GitHub
- «Manual de referência»
- «Experimente Lua online» (em inglês)
Portal das tecnologias de informação
Portal do software livre