Lua (linguagem de programação)

Predefinição:Mais notas

 **Nota:** Para outros significados, veja Lua (desambiguação).

**Lua** é uma linguagem de script de multiparadigma, pequena, reflexiva e leve, projetada para expandir aplicações em geral, por ser uma linguagem 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. Assemelha-se com Python, Ruby e Icon, entre outras.

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 (a 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. 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.

## 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.

## Exemplos

O Programa Olá Mundo pode ser escrito da seguinte forma:

```
print "Olá, Mundo!"

```

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 numeros perfeitos sao ')
   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.

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].
setmetatable(fibs, {
  \_\_index = function(name, n) -- Função chamada se fibs[n] não existir
    name[n] = name[n - 1] + name[n - 2] -- Calcula e grava fibs[n].
    return name[n]
  end
})

```

## 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 usuário criada.

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 dados 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 caracteres "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 estrutura

As tabelas são freqüentemente utilizadas como estruturas (ou objetos), 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 } -- Create new table
print(point["x"])          -- Prints 10
print(point.x)             -- Has exactly the same meaning as line above

```

### Tabela como matriz

Através da utilização de uma tecla numérica, a tabela lembra um tipo de dados de matriz. São de base 1, o primeiro índice é 1 em vez de 0 como é para muitas linguagens de programação.
Exemplo de strings de uma simples matriz:

```
array = { "a", "b", "c", "d" } -- Indices are assigned automatically.
print(array[2])                -- Prints "b". Automatic indexing in Lua starts at 1.
print(#array)                  -- Prints 4. # is the length operator for tables and strings.
array[0] = "z"                 -- Zero is a legal index.
print(#array)                  -- Still prints 4, as Lua arrays are 1-based.

```

Exemplo de um vetor de objetos:

```
function Point(x, y)       -- "Point" object constructor
   return { x = x, y = y } -- Creates and returns a new object (table)
end
array = { Point(10, 20), Point(30, 40), Point(50, 60) } -- Creates array of points
print(array[2].y)                                       -- Prints 40

```

## Projetos que utilizam Lua

Em 2013, a Wikimedia Foundation começou a utilizar a linguagem nas predefinições.

### Projetos

* Adobe Photoshop Lightroom
* 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, Blizzard, SNKPlaymore, Facepunch Studios.

* Angry Birds
* Baldur's Gate
* The Battle for Wesnoth
* Civilization V
* Escape from Monkey Island
* Fable II
* Far Cry
* FlyFF
* Freeciv
* Freelancer
* Garry's Mod
* Grim Fandango
* Impossible Creatures
* Lego Universe
* MapleStory
* MDK2
* Monopoly Tycoon
* Multi Theft Auto
* Psychonauts
* Ragnarok Online
* Roblox
* Street Fighter IV
* The King of Fighters XIII
* Tibia
* Transformice
* The Talos Principle
* World of Warcraft

## Ver também

* Anexo:Linguagens de programação
* Linguagem de programação
* Linguagem de script

## Referências

1. ↑ «Lua News» (em inglês). Lua.org. 30 de Novembro de 2015. Consultado em 14 de Janeiro de 2016.
2. ↑ 2,0 2,1 2,2 2,3 2,4 2,5 2,6 2,7 2,8 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 (Ajuda)
3. ↑ André Rosa (30 de Maio de 2005). «Introdução a LUA, uma poderosa linguagem de programação». Consultado em 14 de Janeiro de 2016.
4. ↑ «Linguagem Lua, criada no Brasil, tem primeiro livro em português sobre programação». O Globo. 07 de Julho de 2015. Consultado em 14 de Janeiro de 2016.
5. ↑ 5,0 5,1 5,2 «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.
6. ↑ «The Battle for Wesnoth Open Source Project on Ohloh». Consultado em 29 de Abril de 2014.

## Bibliografia

* Predefinição:Referência a livro
* Predefinição:Referência a livro
* Predefinição:Referência a livro

## Ligações externas

O Commons possui uma *categoria* contendo imagens e outros ficheiros sobre **Lua (linguagem de programação)**

Predefinição:MediaWiki

* Predefinição:Oficial
* Página oficial (em português)
* Manual de Referência de Lua 5.1 (em português)
* Demonstração online (em inglês)
* Lua Wiki (em inglês) - Wiki oficial
* LuaForge - hospedagem e catálogo de projetos que usam Lua (em inglês)
* Predefinição:Dmoz

Predefinição:Linguagens de programação

* Portal das tecnologias de informação Portal das tecnologias de informação
* Portal do software livre Portal do *software* livre