Você está na página 1de 50

Lua 1

Lua 2

EXPEDIENTE

Egydio Geraldo Passarelli Donati


Vice Presidente

Aguinaldo Silva
Diretor de P&D

GOVERNO DO ESTADO DO

AMAZONAS
José Melo de Oliveira
Governador do Estado do Amazonas

Afonso Lobo Moraes


Secretário de Estado de Fazenda

Rossieli Soares da Silva


Secretário de Estado de Educação

Isa Assef dos Santos


Diretora - Presidente

Niomar Lins Pimenta


Diretor de Tecnologia e Pesquisa
Lua 3
Apresentação do Módulo VII
LUA

Neste módulo vamos abordar a Linguagem Lua que vai nos auxiliar a trabalhar
com lógica de programação na prática e de forma simples e prática.
Iniciaremos o estudo com a montagem do ambiente para trabalharmos com
Lua; depois vamos falar sobre os conceitos básicos da linguagem para depois
aprofundarmos o estudo com comandos mais aprimorados para validar o nosso
conhecimento em lógica de programação. Ao final temos um conteúdo teórico
sobre a API Lua-C.
Começa agora a nossa caminhada para conhecermos mais uma linguagem de
programação que irá nos ajudar na vida profissional.

Professor Pedro Henrique de Oliveira Cavalcante


Lua 4
Lua 5
Lua 6

UNIDADE 1
Linguagem de Programação
Lua
Neste Capítulo estaremos apresentando a Linguagem de Programação
Lua, como também suas características.
Lua 7

1. Apresentação
Segundo Ierusalimdchy (2006), LUA é uma linguagem de script
de programação poderosa, rápida e leve, projetada para estender
aplicações existentes. Ela combina sintaxe simples, tipagem dinâmica e é
interpretada a partir de bytecode para uma máquina virtual baseada em
registradores, tendo gerenciamento automático de memória com coleta
de lixo incremental. Essas características fazem de LUA uma linguagem
ideal para configuração, automação (scripting) e prototipagem rápida.
LUA é uma linguagem de script inteiramente projetada, implementada
e desenvolvida no Brasil pela equipe técnica da PUC-Rio (Pontifícia
Universidade Católica do Rio de Janeiro), ela nasceu e cresceu no Grupo
de Tecnologia em Computação Gráfica – TecGraf da PUC-RIO. Atualmente
é desenvolvida e mantida no LabLua (Laboratório Lua PUC-Rio).

2. Características
No site Lua.org, encontramos as principais características da Linguagem
de Programação LUA que são:
• Linguagem Estabelecida e Robusta
LUA é usada em muitas aplicações industriais como, por exemplo,
o Adobe Photoshop Lightroom; em sistemas embutidos, como por
exemplo o middleware Ginga para o Sistema Brasileiro de TV Digital; em
jogos, como por exemplo World of Warcraft e Angry Birds; como também
na área de segurança sendo a linguagem de script das ferramentas
Wireshark, snort e nmap.
• Rápida e Portátil
LUA tem a reputação de ótimo desempenho. Vários benchmarks
apontam LUA como a linguagem mais rápida dentre as linguagem de
script interpretadas. Além disso, ela pode ser distribuída via um pequeno
pacote e compilada sem modificações em qualquer ambiente que tem o
compilador C padrão. Isso significa que LUA roda em:
- Todos os tipos de Sistemas Operacionais: Unix e Windows;
- Em dispositivos móveis: Android, iOS, BREW, Symbian e Windows
Phone;
- Em microporcessadores embutidos: ARM, Rabbit e Lego
Lua 8

Lego MindStorms;
- E em mainframes da IBM.
• Embutível
LUA é uma engine (motor) rápida e pequena que você pode embutir
na sua aplicação, ou seja, é simples estender LUA com bibliotecas escritas
em outras linguagens e vice versa. Além de C e C++, LUA também pode
trabalhar com as linguagens Java, C#, Smalltalk, Fortran, ADA, Erlang e
outras linguagens de script como Perl e Ruby.
• Poderosa
Um conceito fundamental no projeto de LUA é fornecer meta-
mecanismos para a implementação de construções, em vez de fornecer
inúmeras construções diretamente na linguagem. Um exemplo disso é
o fato de LUA não ser uma linguagem puramente orientada a objetos,
mas existe meta-mecanismos nela para a implementação de classe e de
herança. Essa característica traz uma economia de conceitos, mantém a
linguagem pequena e, ao mesmo tempo, permite que a semântica seja
estendida de maneiras não convencionais.
• Livre
LUA é software livre de código aberto, distribuída sob a licença MIT
(Massachusetts Institute of Technology) e pode ser usada para quaisquer
propósitos, incluindo propósitos comerciais, sem qualquer custo ou
burocracia.
Lua 9

UNIDADE 2
Programando em Lua
Nessa unidade vamos começar a dá os primeiros passos para programar
em Lua, enfatizando suas particularidades.
Lua 10

Ierusalimdchy (2006) fala que programar em LUA não é muito diferente


das outras linguagens existentes hoje, porém precisamos estar atentos
às diferenças. Cada linguagem de programação apresenta características
próprias, e um bom programador sabe explorar essas características. A
partir de agora, vamos apresentar a linguagem LUA e enfatizando suas
particularidades.
Em muitas utilizações reais da linguagem LUA, o interpretador é
distribuído embutido na aplicação final. Afinal, isso é um dos principais
objetivos dessa linguagem: ser portátil e embutível, porém como
não estamos visando a nenhuma aplicação particular, iremos usar o
interpretador independente (modo stand/alone) de LUA.

1. Primeiros Passos
Vejamos agora os primeiros passos para utilizarmos a linguagem LUA
segundo Ierusalimdchy (2006), um dos seus criadores. Para máquina
Windows, uma ótima opção de instalação é a distribuição Lua for Windows.
Essa distribuição é um pacote completo para o Sistema Operacional
Windows, incluindo o interpretador LUA com suas bibliotecas padrão,
um editor e várias bibliotecas extra populares.
Para máquina Unix, algumas distribuições já vêm com o LUA
instalado como padrão. Para outras distribuições, é oferecido pacotes
prontos para instalação como, por exemplo, o Ubuntu: basta instalar o
pacote LUA, que é o interpretador com as bibliotecas padrão. Em qualquer
caso, o interpretador independente de LUA é um programa de linha de
comando, para ser executado por meio de um terminal.
Uma vez instalado, é simples de utilizar o interpretador. LUA não
tem conceito de uma função principal, como o main na Linguagem C.
Qualquer comando passado ao interpretador é executado imediatamente.
O exemplo a seguir é um programa para imprimir uma soma:
Lua 11

Existem outras três formas para executar um programa em LUA:


• Usando a opção -e por linha de comando, conforme exemplo:

• Escrevendo o código em um arquivo e executando-o por linha


de comando, conforme exemplo:

• Escrevendo o código em um arquivo e executado-o dentro do


shell do LUA com o comando dofile, conforme exemplo:

Para cada execução do LUA, o interpretador cria um estado LUA


que persiste até o fim da sua execução. Com isso, todos os efeitos
colaterais de cada comando influenciarão nos comandos seguintes,
mesmo sendo executados em comandos separados. Veja o exemplo:

Cada linha é executada com o um trecho (chunk em inglês)


separadamente, mas o valor da variável global se manterá até o fim da
execução.
Lua 12

2. Convenções Léxicas
Convenções Léxicas são padrões existentes de uma linguagem de
programação para ajudar no desenvolvimento de código fonte, com
o intuito de manter a legibilidade e a confiabilidade de se manter um
código com facilidade de escrita. E para LUA, todos esses padrões serão
apresentados a seguir.

2.1. Identificadores
Identificadores em LUA pode ser quaisquer sequência de letras, dígitos e
underline que não comecem com dígitos. Veja alguns exemplos:

a x x10 _xy variavelComNomeGrande

2.2. Palavras Reservadas


Algumas palavras não podem ser utilizadas como variável, pois estas são
utilizadas pela linguagem LUA. Essas palavras são chamadas Palavras
Reservadas. Veja alguns exemplos no Quadro 1:

Quadro 1 - Exemplos de Palavras Reservadas

and break do else elseif

end false for function if

in local nil not or

repeat return then true type

until while
Lua 13

2.3. Case-Sensitive
LUA é case-sensitive, ou seja, a linguagem diferencia palavras com letras
maiúsculas e letras minúsculas. Com isso a palavra and é uma palavra
reservada mas And e AND são duas variáveis distintas.

2.4. Comentários
Comentários em LUA podem começar com um hífen duplo -- e terminam
até o fim da linha e também pode ser um bloco e começar com a sequência
--[[ e terminar com a seqüência ]]. Veja o exemplo:

2.5. Variáveis Globais


Variáveis globais em LUA não precisam ser declaradas. Você simplesmente
associa um valor a uma variável global para criá-la. LUA não trata com
erro quando uma variável não existe, apenas identifica com um valor nil.
Veja o exemplo:

3. Funções Nativas
Em Lua, temos várias funções pré-definidas que ajudam na construção do
nosso código, e dentre elas podemos destacar as Funções matemáticas
(math.), as Funções de Entrada e Saída (io.), as Funções de Manipulação
de arquivos (file.) e as Funções do Sistema Operacional (os.).
Lua 14

Exercícios
1. Execute o seguinte código em Lua para testar o ambiente e informe o
resultado.
a=1
for i=1,10 do
print(i+a)
end

2. Informe onde está os X erros no código em Lua abaixo.


a=1
for and=1,10 do
6aa = 2
print(and+a+6aa)
a=A+1
end

3. Pesquise e escreva com poucas palavras o que faz as seguintes funções:

math.abs
math.cos
math.exp
math.max
math.min
math.pi
math.pow
math.random
math.sin

io.close
io.open
io.read
io.write

file.close
file.lines
file.read
file.write

os.clock
os.date
os.difftime
os.execute
os.remove
os.rename
os.time

4. Crie quatro exemplos simples de código em Lua utilizando pelo menos


uma função de cada tipo (math, io, file e os).
Lua 15

UNIDADE 3
Tipos de Valores
Neste capítulo vamos ver os tipos de valores que são utilizados na
Linguagem de Programação LUA.
Lua 16

LUA é uma linguagem de tipagem dinâmica e isso significa que não é


preciso definir o tipo da variável que será utilizada. Cada variável pode
conter qualquer tipo de valor, independente da situação. Existem seis
tipos de tipos básicos em LUA: nil, boolean, number, string, function, e
table. A função type() retorna o tipo de cada valor ou variável, conforme
figura:

Cuidado!

Geralmente quando é usada uma mesma variável


para diferentes tipos, o resultado é um código
difícil de entender e de manutenção. Portanto evitem
essa situação.

Vejamos agora um pouco sobre os seis tipos existentes em LUA:

1º Tipo: Nil
O tipo nil é um tipo de valor único e significa um valor nulo. Em
outras palavras, LUA utiliza esse tipo para representar a ausência de um
valor útil para uma variável.

2º Tipo: Booleans
O tipo boolean possui dois valores: false e true. Esses tipos são
comumente utilizados para trabalhar com estruturas de condições.
Lua 17

3º Tipo: Numbers
O tipo numbers representa números com dupla precisão e ponto
flutuante. Isso significa que com esse tipo é possível trabalhar com
qualquer tipo de números, sendo eles inteiros ou com casas decimais de
tamanho infinito.

4º Tipo: Strings
O tipo strings é utilizado para trabalhar com sequência de
caracteres, suportando qualquer caracter. Strings em LUA possuem
valores imutáveis: você não consegue modificar um caracter dentro de
uma string, como na linguagem C; em vez disso, você consegue criar uma
nova string com a modificação desejada a partir de uma string existente.
Veja o exemplo:

Strings em LUA possuem gerenciamento automático de memória.


Isso significa que o desenvolvedor não precisa se preocupar com alocação
de deslocação de memória, pois LUA trata isso para você. Uma string
pode conter uma letra ou um livro inteiro.
Podemos delimitar uma string em LUA com aspas simples ou
aspas duplas. Veja o exemplo:
Lua 18

String em LUA pode conter sequências de escape como na


linguagem C, conforme Quadro 2:

Quadro 2 - Sequência de Escape do String em LUA

\b Back space
\f Form feed
\n New line
\r Carriage Return
\t Horizontal tab
\v Vertical tab
\\ Contra barra
\' Aspa simples
\” Aspa dupla

Veja os exemplos:

LUA fornece conversão automática entre numbers e strings em


tempo de execução. Qualquer operação numérica aplicada a uma string
LUA tentará converter a String para um número. Veja os exemplos:

No primeiro exemplo, a string “10” foi convertida para 10 e


somada com 1, resultando no valor 11.
No segundo exemplo, LUA não converteu a operação de soma,
mantendo apenas a seqüência de caracter.
Lua 19

No terceiro exemplo, LUA retornou erro, pois não foi possível


converter a string “Hello” em um number para concluir a operação de
soma.
Caso precise converter um number em uma string, utilize a função
tostring(). Veja os exemplos:

No primeiro exemplo, a comparação retornou false porque


para o interpretador, 10 é um number e “10” é uma string, tornando-os
diferentes.
No segundo exemplo, o number foi convertido para string,
possibilitando a comparação com a outra string verdadeira.
Em LUA, para saber o tamanho de uma string, basta usar o operador
# antes da variável. Veja o exemplo:

5º Tipo: Tables
O tipo table implementa uma coleção de dados (array) associativos.
Um array associativo é um array que pode ser indexado por number, string
ou qualquer outro tipo, exceto por nil. Além disso, tables não possuem
tamanho fixo: você pode adicionar quantos elementos que for necessário
em uma table. Tables é o mecanismo principal de estrutura de dados em
LUA, com ele é possível representar arrays ordinários, tabela de símbolos,
set, record, queues e outros tipos de estrutura.
Para criar tables em LUA, é necessário utilizar a seguinte seqüência
{}. Veja os exemplos:
Lua 20

Foi criada uma table com o nome a. Em seguida, foi criado um


elemento nessa table com index do tipo string ‘x’ e com valor 10. Após
isso, foi criado outro elemento com index do tipo number 20 e com o
valor “teste”. Ao final, foi incrementado o valor 10 e exibido o resultado.
Seguem mais exemplos de criação de tables:

Nesse exemplo, temos uma table com os dias da semana. Atente


para o index inicial, que é 1 e não 0.

Nesse exemplo temos outra forma de criar tabela passando o


index e o valor e usando o operador, ao invés do operador [] para indexar
um elemento da table.
Lua 21

Nesse exemplo temos uma table dentro de outra table. Essa


operação é chamada de Tables Aninhadas.

Nesse exemplo temos uma table com caracteres especiais como


index.

6º Tipo: Functions
O tipo function é o tipo primário em LUA. Isso significa que
funções podem ser armazenadas em variáveis, passadas como argumento
para outras funções e retornadas como resultado. Tal facilidade traz
flexibilidade para a linguagem: um programa pode redefinir uma função
ou adicionar uma nova funcionalidade.
LUA pode trabalhar com funções implementadas em LUA e com
funções implementadas em linguagem C. Isso é possível porque todas
as bibliotecas padrão de LUA foram escrita em linguagem C. As duas
linguagens compreendem funções de manipulação de string, E/S, acesso
as operações básicas do Sistema Operacional, funções matemáticas e
debugging.
Lua 22

Exercícios
1. Execute o código em Lua abaixo e informe o resultado

a = "Isto é um 'teste'!!!"
b = [[Isto é um
"teste"!!!]]
c = 'Isto é um\n"teste"!!!'
print(a)
print(b)
print(c)

2. No código abaixo, qual das linhas é um código em Lua válido? Explique


de forma simples porque as outras linhas não são um código válido.

x = [[O "rato" roeu a 'roupa' do [rei] de Roma.]]


x = 'O "rato" roeu a roupa do [[rei]] de Roma.'
x = "O rato roeu a 'roupa' do [[rei] de Roma."
x = [[O "rato" roeu a 'roupa' do [rei] de Roma.]]
x = "O 'rato' roeu a "roupa" do [rei] de Roma."
)

3. Implemente um código em Lua para armazenar os meses do ano em


uma estrutura do tipo table.

4. Implemente um código em Lua para armazenar as estações do ano em


uma table com os index abaixo e imprima o conteúdo da table utilizando
os index:

"inv" -> "inverno"


"ver" -> "verao"
"out" -> "outono"
"pri" -> "primavera"
Lua 23

5. Implemente um código em Lua para armazenar os dados de 3


estudantes em uma table:

nome: João da Silva


endereco: Rua A, casa B
telefone: 2222-2222

nome: Maria Joaquina


endereco: Rua C, casa D
telefone: 3333-3333

nome: Pedro Joaquim


endereco: Rua E, casa F
telefone: 4444-4444
Lua 24

UNIDADE 4
Operações
Neste capítulo vamos conhecer as diversas operações que são utilizados
na Linguagem de Programação LUA, como também suas concatenações
e precedências.
Lua 25

1. Operações Aritméticas
Operações Aritméticas são expressões em que os operadores são
aritméticos e os operandos são valores numéricos (inteiro ou ponto
flutuante). Com essas operações, conseguimos realizar operações
aritméticas básicas (soma, subtração, divisão e multiplicação) e outras
mais específicas. LUA suporta as operações básicas de aritmética:
• (+) adição
• (-) subtração
• (*) multiplicação
• (/) divisão
• (%) módulo
• (^) exponenciação
• (-) negação
Veja os exemplos:

Para manipulação de number com casas decimais, LUA


disponibiliza o operador % para trabalhar com a parte inteira e com a
parte fracionária. Veja o exemplo:
Lua 26

Nesse exemplo, temos uma atribuição do valor de pi para a


variável x e, em seguida, é exibido o valor dessa variável. Após isso, com
o uso do operador %1, é exibida somente a parte fracionária do número.
Depois, com o uso do operador x-x%1, é exibida somente a parte inteira
do número. E por último, com o uso do operador x-x%0.01, é exibido o
número com apenas duas casas decimais.

2. Operações Relacionais
LUA suporta as seguintes operações de relacionamento:
• (>) maior que
• (>=) maior ou igual que
• (<) menor que
• (<=) menor ou igual que
• (==) igual
• (~=) diferente
Todas essas operações sempre retornam o valor ou true ou false.
Veja os exemplos com números:

As mesmas operações podem ser realizadas com strings. Veja os


exemplos:
Lua 27

Nesse exemplo, vemos que com operadores relacionais é possível


implementar um algoritmo para ordenar nomes em ordem alfabética.

3. Operadores Lógicos
Operadores Lógicos são operadores que unem uma ou mais expressões
lógicas e dão um novo significado lógico a elas. LUA suporta os seguintes
operadores lógicos: and, or e not. Seguem os exemplos:

Além de operações básicas, LUA trabalha com os operadores


lógicos de forma particular. Vejamos as regras para cada um deles:

• Operador and: retorna o primeiro argumento caso o mesmo


seja nil ou false. Caso contrário, retorna o segundo argumento;
• Operador or: retorna o primeiro argumento caso o mesmo não
seja nil ou false. Caso contrário, retorna o segundo argumento;

Seguem os exemplos:
Lua 28

4. Concatenação
Segundo a Wikipédia, concatenação é o ato de unir o conteúdo de
duas strings. Por exemplo, considerando as strings “casa” e “mento” a
concatenação da primeira com a segunda gera a string “casamento”.
Para concatenação de strings, LUA utiliza o operador (..). Caso algum dos
argumentos é um number, LUA converte este number em uma string.
Seguem os exemplos:

5. Precedência
Existe precedência de operadores em LUA. No quadro 3, temos a ordem
de precedência, do maior para o menor:

Quadro 3 - Ordem de Precedência

# Operadores

1 ^
2 not # -(unário)
3 */%
4 +-
5 > >= < <= == ~=
6 and
7 or

Seguem exemplos de como ficam operadores respeitando a


precedência:
Lua 29

Operadores Equivalência

a+i < b/2*1 (a+i) < ((b/2)+1)


5+x^2*8 5+((x^2)*8)
a < y and y <= z (a < y) and (y <=z)
-x^2 -(x^2)

Caso a precedência seja de valor igual, é recomendado o uso de


parênteses para evitar falha na sequência.
Lua 30

Exercícios
1. Implemente um código em Lua para calcular a área de um círculo cujo
raio deve ser informado.
area = π * r ^2

area = π * r ^2

2. Implemente um código em Lua que leia 2 números inteiros, calcule e


exiba a média aritmética e o produto dos números.

3. Implemente um código em Lua que leia 3 números, calcule qual é o


menor e qual é o maior número e exiba escrevendo a seguinte mensagem:
“O maior número é X e o menor número é Y”.

4. Implemente um código em Lua que classifique o nadador de acordo


com a sua idade:

infantil A = 5 - 7 anos
infantil B = 8-10 anos
juvenil A = 11-13 anos
juvenil B = 14-17 anos
adulto = maiores de 18 anos

5. Implemente um código em Lua para resolver a expressão das seguintes


fórmulas matemáticas (defina o valor das variáveis no início do código):

a) B
A+
X = C
E
D−
F

2 X 2 − 3 X ( X +1) X +1
+
b) Y = 2 X
2X
Lua 31

6. Implemente um código em Lua que calcule as seguintes expressões


(utilizando parênteses).

a) 2 + 3 * { 23 - 12 + [ { ( 123 / 34 ) + 10 } / 2 - 1 * ( 45 - 12 ) ] / 3 }
b) [ ( 2 * 3 ) *2 - 1 ] * 4
c) ( 2 + [ 2 * 3 - ( 4 / 20 ) * 2 ] )/ (10 * { [ ( 7 * 3 ) - 2 ] * 3 })

7. Implemente um código em Lua que leia dois números inteiros A e B.


Se os valores forem iguais, calcule a soma dos números. Caso contrário,
calcule o produto dos números e exiba o resultado.

8. Implemente um código em Lua para satisfazer o fluxo abaixo:

9. Implemente um código em Lua para satisfazer o fluxo abaixo:


Lua 32

UNIDADE 5
Comandos
Nessa unidade vamos conhecer os comandos que trabalhamos em
LUA. Ela trabalha com vários comandos de programação e que são bem
similares à Linguagem C e Pascal. Os comandos convencionais incluem
os de atribuição, estrutura de controle e variáveis locais.
Lua 33

1. Atribuição
Atribuição é o comando básico de associação a um valor, a uma variável.
Em LUA, podemos realizar múltiplas atribuições, ou seja, podemos associar
uma lista de valores para uma lista de variáveis. Veja os exemplos:

Segue um exemplo de como realizar a troca de valores de duas


variáveis em LUA utilizando múltiplas atribuições:

Caso a lista de valores não tenha a mesma quantidade da lista de


variáveis, LUA preenche o valor com nil. Veja o exemplo:

2. Variável Local
Até aqui trabalhamos sempre com variáveis do tipo global: variáveis que
são declaradas em qualquer parte do código e utilizadas sem nenhuma
restrição. Mas LUA disponibiliza um mecanismo para criarmos variáveis
locais e que pode ser utilizada em um chunk. Veja o exemplo:
Lua 34

var=1

for i=1,10 do
local var=10
print(i+var)
end

print(var)

A variável var que está na linha 1 é uma variável global e que foi
inicializada com o valor 1. Já a variável var que está na linha 4 é uma
variável local e que só existe no contexto dentro do laço de repetição, por
isso que o resultado do print começa com o valor 11 (i=1 e var=10).

3. Estrutura de Controle
LUA fornece um pequeno conjunto de estrutura de controle, com if para
controle de condição e while, repeat e for para controle de repetição.
Todos os comandos possuem um terminador explícito: end para os
controles if, for e while e until para o controle repeat.

3.1. If then else


O controle if testa uma condição e executa a parte then caso a
condição seja verdadeira, caso contrário executa a parte else. A parte else
é opcional. Veja o exemplo:
Lua 35

a=2

if a >= 10 then
print("a maior ou igual 10")
else
print("a menor 10")
end

LUA também suporta o controle if aninhados através do comando


elseif. Segue o exemplo:

a=1
b=2
op = "+"

if op == "+" then
print(a+b)
elseif op == "-" then
print(a-b)
elseif op == "*" then
print(a*b)
elseif op == "/" then
print(a/b)
else
print("operacao invalida")
end

3.2. While
O controle while é utilizado para laços de repetição. E, para isso, ele
precisa de uma condição para se manter nessa repetição. Essa condição é
verificada toda vez que o laço é finalizado. Segue o exemplo:
Lua 36

a={'a', 'b', 'c', 'd', 'e'}

i=1

while a[i] do
print(a[i])
i=i+1
end

3.3. Repeat
O controle repeat é outra forma de se trabalhar com laços de
repetição, só que a diferença é que a condição fica dentro da estrutura
de repetição. Segue o exemplo:

var=10
repeat
print(var)
var=var-2
until var < 0

3.4. For
O controle for possui duas variações: o for numérico e o for
genérico. Como já diz o nome, o for numérico trabalha com números.
Nesse caso, é necessário termos uma variável com um valor inicial e o
valor de parada. Segue o exemplo:

for i=1,10 do
print(i)
end
Lua 37

Além do valor inicial e o de parada (que são obrigatórios), temos


também o valor de incremento que pode ser utilizado. Segue o exemplo:

for i=1,10,2 do
print(i)
end

Já o for genérico trabalha com estruturas que possuem iterator.


Segue o exemplo:

a={'a', 'b', 'c', 'd', 'e'}

for k, v in pairs(a) do
print(k, v)
end

A biblioteca padrão do Lua disponibiliza a função pairs(), que é


uma função que trabalha com o index e o valor de um table, conforme
é visto no exemplo acima. A variável k retorna os valores dos indexs do
array e a variável v retorna os valores que estão associados ao index.
Lua 38

Com esse exemplo, fica bem claro o poder do for genérico junto
com a estrutura iterator: podemos atravessar qualquer tipo de dados. E
isso acontece porque a biblioteca padrão do Lua disponibiliza funções de
acesso a todos os tipos de dados: array usa o ipairs(), file usa io.lines(),
table usa pairs() e string usa string.gmatch(). Seguem os exemplos:

s = "ola mundo para lua"


for w in string.gmatch(s, "%a+") do
print(w)
end

Nesse exemplo, temos um código que pula de palavra em palavra


através da função gmatch junto com a expressão “%a+” própria do Lua.

Aprendendo lua de uma maneira bem simples


teste com arquivos
lendo linhas de um arquivo

filename='arquivoteste.txt'

for line in io.lines(filename) do


print(line)
end

Nesse exemplo, temos um arquivo de texto que é lido através


da função io.lines e que é exibido no print que está dentro do laço de
repetição. Observe que a condição de parada é também resolvida pela
função io.lines.
Lua 39

3.5. Break
A estrutura de controle break é utilizada para finalizar um laço de
repetição (repeat, while ou for). Segue o exemplo:

for i=1,100 do
print(i)
if i==15 then
break
end
end

3.6. Return
A estrutura de controle return é utilizada para finalizar uma função
com o sem o retorno de um valor. Convém utilizar o return no fim da
função, a fim de manter a integridade do código. Seguem os exemplos:

function soma(a,b)
return a+b
end

print(soma(2,3))
Lua 40

Exercícios
1. Implemente um código em Lua que calcule e mostre a média aritmética
de um array.

x= {9,5,11,4,2,7,8,1,3}

2. Implemente um código em Lua para ordenar o array do exercício


anterior.
3. Implemente um código em Lua para gerar números inteiros aleatórios
e armazenar em um array.

4. Implemente um código em Lua para calcular o fatorial de um número.

N! = N*(N-1)*(N-2)*...*1
5! = 5*4*3*2*1 = 120

5. Implemente um código em Lua para somar os números pares positivos


menores que 1000 e exibir o valor dessa soma.

6. Implemente um código em Lua para calcular a série de Fibonacci até o


décimo termo.

1,1,2,3,5,8,13,21,34,55

7. Implemente um código em Lua para ler o valor de x e calcular a seguinte


expressão:

y = (x+1)+(x+2)+(x+3)+(x+4)+(x+5)+…(x+100)
Lua 41

UNIDADE 6
Funções
Nesta última unidade vamos estudar funções e seus multiplos resultados
e parâmetros.
Lua 42

Funções em LUA são os principais mecanismo para abstração de um


controle, pois com funções, o programador consegue separar uma tarefa
específica dentro de uma função de forma simples e clara ou computar
um valor e retorná-lo sem atrapalhar a execução principal do código.
Em Lua, não declaramos funções de forma estática: as funções
são criadas dinamicamente, durante a execução de um programa. Veja o
exemplo:

(function (a,b) print(a+b) end) (10, 20)


Esse trecho de código cria uma função que imprime a soma dos
dois parâmetros passados e chama essa função. Após a execução do
comando, não existe mais referência para a função e portanto os recursos
usados por ela (memória) serão automaticamente liberados.
De modo geral, a sintaxe de uma função é:

function (<pars>)
<body>
End
Onde:
<pars> são os parâmetros da função;
<body> é o corpo da função, o que será feito pela função.
Vamos a um exemplo simples:

function maiorque(a, b)
if a>b then
return(a ..' maior que ' .. b)
else
return(b .. ' maior que ' .. a)
end
end

print(maiorque(2,11))

Nesse exemplo temos uma função que exibe qual o maior valor
entre os parâmetros passados e retorna uma string com essa informação.
Tendo isso bem encapsulado, fica fácil colocar o retorno da função em
um print para exibir o resultado.
Lua 43

1. Múltiplos Resultados
Uma grande vantagem de se trabalhar com função em LUA e a
possibilidade de retornar mais de um resultado. Segue um exemplo:

function somaemultiplica(a, b)
soma = a+b
mult = a*b
return soma, mult
end

print(somaemultiplica(4,5))

Nesse exemplo temos uma função que soma e multiplica o valor


dos parâmetros passados e retorna as duas operações ao mesmo tempo.
Isso trás uma grande vantagem na utilização da função e na simplificação
de código.

2. Múltiplos Parâmetro
Outra grande vantagem de trabalhar com funções em LUA é a passagem
de parâmetros indefinidamente. Segue o exemplo:

function somatudo(...)
soma = 0
for i, v in ipairs{...} do
soma = soma + v
end

return soma
end

print(somatudo(4, 5, 2, 3, 1))

Nesse exemplo temos uma função que realiza a soma através de


um laço de repetição os valores passados de forma indefinida (quantidade
de parâmetros). O valor da soma é armazenado na variável soma e é
retornada pela função.
Lua 44

Exercícios
1. Implemente um código em função em Lua que receba como parâmetro
um valor inteiro e que retorna o valor lógico True caso seja positivo e
False caso contrário.

2. Implemente um código em função em Lua que receba três valores


inteiros e retorne-os ordenados em forma crescente.

3. Implemente um código em função em Lua que receba um valor


indefinido de parâmetros e retorne a média aritmética dos parâmetros.

4. Implemente um código em função em Lua que receba a temperatura


em Fahrenheit e que deve converter para Celsius. Segue a fórmula:

C = ((F-32)/9)*5

5. Implemente um código em função em Lua que receba como parâmetro


o número de lados de um polígono regular e que exiba a seguinte
informação:
• Se o número de lados for igual a 3, escrever TRIÂNGULO e o
valor do seu perímetro.
• Se o número de lados for igual a 4, escrever QUADRADO e o
valor da sua área.
• Se o número de lados for igual a 5, escrever PENTÁGONO.
• Se não for nenhuma das opções, escrever INVÁLIDO.

6. Implemente um código em Lua que simule uma calculadora simples


com as seguintes operações: soma, subtração, multiplicação, divisão,
resto e potência. Todas essas operações devem ser feitas com funções.

7. Implemente um código em função em Lua que recebe como parâmetro


um valor entre 1 e 9 e exibe a tabuada desse número (entre 1 e 10).

8. Implemente um código em função em Lua que informe se o parâmetro


informado (string) é palíndromo ou não. Segue exemplo:
Lua 45

kayak -> é palíndromo


casa -> não é palíndromo
arara -> é palíndromo
hoje -> não é palíndromo

Como comentamos no início, um dos pontos fortes de Lua é sua


facilidade para se comunicar com a linguagem C, no texto a seguir vamos
ver como essa comunicação é feita.
Lua 46

Texto Complementar: A API Lua–C


LUA foi projetada para se comunicar com C. Isso é tão importante que Lua é organizada como uma
biblioteca em C, não como um programa. O programa Lua, que temos usado como exemplos, na verdade é
um pequeno programa com menos de 400 linhas de código que é um cliente da biblioteca LUA. Essa biblio-
teca exporta pouco menos que 100 funções, que permitem executarmos trechos de código LUA, chamar-
mos funções, registrarmos funções C para serem chamadas por LUA, manipularmos tabelas, e outras opera-
ções básicas.
Sempre que manipulamos uma API como a de LUA, é importante lembrar que trabalhamos com dois
níveis de abstração simultâneos. Por um lado, existe o nível do programa em C, que estamos escrevendo.
Por outro lado, existe o nível do programa em Lua que está sendo manipulado por esse programa C. Por
exemplo, existe uma função na API para consultar o valor de uma variável global. Quando chamamos essa
função, estamos executando uma chamada de função, no nível C, mas estamos consultando uma global no
nível Lua.

Uma consideração importante na implementação de Lua é o tamanho e a portabilidade do código.


Lua é comumente usada em plataformas bastante não convencionais,como consoles de jogos, conversores
(set-top box) para TVs, cameras fotográficas, etc. Para diminuir seu tamanho e aumentar sua portabilidade,
o código de Lua é dividido em três partes: o núcleo, uma biblioteca auxiliar e as bibliotecas padrão. O
núcleo contém toda a parte básica de Lua, como o pré-compilador, o interpretador, os algoritmos de mani-
pulação de tabela e de coleta de lixo. Porém, ele não assume nada sobre o sistema operacional. Por exem-
plo, o núcleo faz toda sua alocação de memória chamando uma função externa, que deve ser fornecida a
ele na sua inicialização. Da mesma forma, o núcleo não lê arquivos, mas carrega trechos de código chaman-
do uma função externa apropriada. A API do núcleo é totalmente definida no arquivo lua.h; todos os nomes
definidos por essa API tem o prefixo lua_.

A estrutura do núcleo é bastante apropriada para aplicações embarcadas, rodando em plataformas


não convencionais que muitas vezes nem dispõem de um sistema operacional. Para plataformas mais con-
vencionais, entretanto, ela é demasiadamente detalhista. Para isso existe a biblioteca auxiliar. Essa bibliote-
ca usa a API do núcleo e funções normais do sistema operacional para oferecer uma interface de mais alto
nível para o programador. Essa API auxiliar é definida no arquivo lauxlib.h; todos os nomes definidos por
essa API tem o prefixo luaL_. Neste texto vamos usar a biblioteca auxiliar sempre que necessário, pois assu-
mimos estar programando em uma plataforma convencional.

A comunicação Lua–C é bi-direcional. Por um lado, Lua pode chamar funções que na verdade estão
escritas em C. Por exemplo, todas as bibliotecas padrão de Lua, como para manipulação de strings e para
manipulação de arquivos, são escritas em C. Por outro lado, também é bastante fácil C chamar funções
escritas em Lua. Isso permite que partes de um programa escrito em C sejam configuráveis por meio de
código Lua.

Uma distinção útil é entre embutir (embed) e estender uma linguagem de script. Embutir é usar a
linguagem como uma biblioteca C dentro de um programa hospedeiro, enquanto estender é escrever o
programa principal na linguagem dinâmica estendida com funções escritas em C. Uma linguagem dinâmi-
ca poder chamar código escrito em C é bastante comum; mesmo em Java podemos fazer isso, por meio da
Java Native Interface. Entretanto, poucas linguagens oferecem suporte adequado para serem embutidas, e
portanto, induzem o projetista a usar uma arquitetura de extensão, com o programa principal escrito na
linguagem dinâmica [Muhammad and Ierusalimschy 2007]. Em Lua, podemos escolher qual é a melhor
arquitetura para cada aplicação particular. Por exemplo, tanto World of Warcraft quanto Ginga usam Lua de
forma embutida, enquanto o Photoshop Lightroom estende Lua.

[Ierusalimschy, Roberto; Programming in Lua, 2006].


Lua 47

Glossário

Wireshark: é um programa que analisa o tráfego de rede e o organiza


por protocolo.
Snort: é um software livre que detecta intrusos na rede (NIDS).
Nmap: é um software livre que realiza port scan.
Linguagem de Script: são linguagens de programação executadas do
interior de programas e/ou de outras linguagens de programação, não
se restringindo a esses ambientes
Bytecode: é o resultado de um processo semelhante ao dos compiladores
de código-fonte que não é imediatamente executável.
Benchmarks: processo de busca das melhores práticas numa determinada
indústria e que conduzem ao desempenho superior.
ARM: é uma arquitetura de processador 32bits usada principalmente em
sistemas embarcados.
BREW: é uma plataforma aberta desenvolvida pela empresa Qualcomm
para criação e distribuição de aplicações para telefones celulares.
MindStorms: é uma linha do brinquedo LEGO lançado comercialmente
em 1998, voltado para a educação tecnológica.
Lua 48

Referências Bibliográficas

IERUSALIMSCHY, Roberto. Programming in Lua. Roberto Ierusalimschy,


2006

LUA for Windows. Disponível em: <http://luaforwindows.luaforge.


net> Acessado em 10 de abril de 2015.

A Linguagem de Programação LUA. Disponível em: <http://www.lua.


org/portugues.html>. Acessado em 10 de abril de 2015
Lua 49

CRIAÇÃO DE CONTEÚDO
Pedro Henrique de Oliveira Cavalcante

REVISÃO TÉCNICA
Alessandro Carlos Frota Freire

ORIENTAÇÃO E REVISÃO DIDÁTICA


Débora Claudiano da Silva

PROJETO GRÁFICO E EDITORAÇÃO


Suzianny Souza de Melo

ILUSTRAÇÕES
Emanuel Braga Ferreira

COORDENAÇÃO GERAL
Débora Claudiano da Silva
Lua 50

Você também pode gostar