Conceitos básicos da linguagem de programação Lua, Exercícios de Português (Gramática - Literatura)

Baixe Conceitos básicos da linguagem de programação Lua e outras Exercícios em PDF para Português (Gramática - Literatura), somente na Docsity!

Índice

• Curso de Lua 3.
• Introdução
• O que é Lua?
• Por que Lua?
• Execução..................................................................................................................
• Observações
• Variáveis e Escopo
• Tipos de Dados
• Variáveis Globais
• Variáveis Locais........................................................................................................
• Upvalues
• Exercícios de Fixação I..................................................................................................
• Atribuição e Operadores ..............................................................................................
• Atribuição Simples e Múltipla ...................................................................................
• Operadores Aritméticos ............................................................................................
• Operadores Relacionais ............................................................................................
• Operadores Lógicos ..................................................................................................
• Operador de Concatenação .......................................................................................
• Exercícios de Fixação II................................................................................................
• Estruturas de Controle de Fluxo....................................................................................
• Expressões...............................................................................................................
• Tomada de Decisão ..................................................................................................
• Laços Iterativos........................................................................................................
• Exercícios de Fixação III...............................................................................................
• Tabelas.......................................................................................................................
• Construtores ............................................................................................................
• Acessando Dados .....................................................................................................
• Exercícios de Fixação IV ..............................................................................................
• Funções......................................................................................................................
• Declaração...............................................................................................................
• Retorno ...................................................................................................................
• Chamada.................................................................................................................
• Exercícios de Fixação V ...............................................................................................
• Funções Pré-Definidas .................................................................................................
• call .........................................................................................................................
• dofile ......................................................................................................................
• dostring...................................................................................................................
• next ........................................................................................................................
• nextvar....................................................................................................................
• type ........................................................................................................................
• tonumber ................................................................................................................
• tostring ...................................................................................................................
• print........................................................................................................................
• assert ......................................................................................................................
• getn ........................................................................................................................
• foreach....................................................................................................................
• foreachi...................................................................................................................
• foreachvar ...............................................................................................................
• tinsert .....................................................................................................................
• tremove...................................................................................................................
• sort .........................................................................................................................
• Exercícios de Fixação VI ..............................................................................................
• Biblioteca: Manipulação de Strings ...............................................................................
• strlen ......................................................................................................................
• strsub......................................................................................................................
• strlower...................................................................................................................
• strupper ..................................................................................................................
• strrep ......................................................................................................................
• ascii ........................................................................................................................
• format .....................................................................................................................
• format – Tipos Aceitos..............................................................................................
• Expressões Regulares...................................................................................................
• strfind .....................................................................................................................
• gsub........................................................................................................................
• Exercícios de Fixação VII .............................................................................................
• Biblioteca: Funções Matemáticas ..................................................................................
• Biblioteca: Funções de E/S ...........................................................................................
• readfrom .................................................................................................................
• writeto ....................................................................................................................
• appendto .................................................................................................................
• read ........................................................................................................................
• write .......................................................................................................................
• remove....................................................................................................................
• rename....................................................................................................................
• tmpname.................................................................................................................
• date ........................................................................................................................
• date - Formatos........................................................................................................
• exit .........................................................................................................................
• getenv .....................................................................................................................
• execute ...................................................................................................................
• Exemplo Completo ......................................................................................................
• Exercícios de Fixação VIII ............................................................................................
• Respostas dos Exercícios de Fixação .............................................................................
• Bibliografia .................................................................................................................

Introdução

O que é Lua?

• Uma linguagem de script
• Uma linguagem de extensão
• implementada como uma biblioteca em C

Por que Lua?

• Simples e flexível
• Pequena
• Eficiente
• Portável
  • A biblioteca inteira escrita em ANSI C, compilando o mesmo código-fonte em qualquer plataforma

Execução

O interpretador de Lua command-line e as bibliotecas para incluir Lua em programas C podem ser baixados em: http://www.lua.org (buscar a versão 3.2. A atual é 5.0)

CGILua 3.2 pode ser baixado em http://www.tecgraf.puc-rio.br/cgilua

Para rodar um programa Lua com o interpretador command-line , basta digitar: lua nomedoarquivo.lua

Ao rodar o interpretador sem parâmetros, ele funciona em modo interativo.

Observações

• Não há formatação rígida para o código Lua. Tanto faz colocar um comando por linha ou diversos comandos em uma mesma linha, que podem ser separados por espaço ou ponto-e-vírgula.
• Lua é case-sensitive
• Comentários em Lua iniciam-se com traços duplos (--) e seguem até o final da linha.
• Possui gerenciamento automático de memória e coleta de lixo.

• function: Funções em Lua são do tipo de dados function. É possível armazená-las em variáveis, em índices de tabelas, passá-las como parâmetros para outras funções ou retorná-las como resultados.

Ex: function func1() … end (ou func1 = function() … end) func1 é uma variável que armazenada uma função, ou seja, um valor do tipo function

Para executar a função, basta chamar: func1()

• userdata: Armazena um ponteiro do tipo void* de C. Útil para quem utiliza Lua dentro de um programa em C.
• table: Implementa vetores associativos – valores indexados por qualquer outro tipo (exceto nil ). Principal mecanismo de estrutura de dados de Lua. Uma variável contém uma referência a uma tabela, e não a própria tabela. Designação, passagem de parâmetros e retorno manipulam referências a tabelas, não implicando em cópia. Tabelas devem ser criadas antes de serem utilizadas. Ex: a = {} a[1] = “Teste” a[“nome”] = “João” (equivale a a.nome = “João”) a.func1 = function() … end b = {1, “casa”; nome1 = “João”} -- resulta em: b[1] = 1, b[2] = “casa”, -- b.nome1 (ou b[“nome1”]) = “João”

Variáveis não são tipadas em Lua, somente os valores armazenados nas mesmas o são A seguinte seqüência de instruções é válida: a = nil -- armazena em a um dado do tipo nil a = 1 -- passa a armazenar em a um dado do tipo number a = “Teste” -- passa a armazenar em a um dado do tipo string

Variáveis Globais

Não precisam ser declaradas, podem ser utilizadas diretamente.

Ex: a = 2 -- a não foi declarada anteriormente. Recebe o valor 2 e é visível em todo o programa b = (c == nil) -- b e c não foram declaradas anteriormente. b recebe o valor 1 e é visível em todo o programa. c continua indefinida (ou seja, nil)

Variáveis Locais

Podem ser declaradas em qualquer lugar dentro de um bloco de comandos. Têm escopo somente dentro daquele bloco. Quando declaradas com o mesmo nome que uma global, encobrem o acesso à global naquele bloco.

Ex: local a -- a é declarada e recebe nil

Ex: local a, b = 1, “x” -- declara a e b, onde a = 1 e b = “x”

Ex: a = 2 -- variável global a recebe 2 if (a > 0) then local b = a -- variável local b recebe valor da global a -- (dentro do escopo do if) a = a + 1 -- altera o valor da variável global a local a = b -- declara variável local a que recebe valor de b print(a) -- imprime valor de variável local a -- (que obscureceu a global a) end print (a) -- imprime o valor da variável global a -- (a local já não existe)

Upvalues

Uma função pode acessar suas próprias variáveis locais (incluindo parâmetros passados a ela) ou variáveis globais (quando não encobertas por locais).

Uma função não pode acessar variáveis locais de um escopo externo, já que essas variáveis podem não mais existir quando a função é chamada.

Ex: function f() local a = 2 local g = function() local b = a -- erro: a é definida num escopo externo end end Porém, pode acessar o valor de uma variável local de um escopo externo, utilizando upvalues que são valores congelados quando a função dentro de onde eles aparecem é instanciada. Para acessar esses valores, utiliza-se a notação % seguido do nome da local do escopo externo. Ex: function f() local a = 2 local g = function() local b = %a -- ok, acessa valor congelado de a no momento -- em que a função foi instanciada end end

Atribuição e Operadores

Atribuição Simples e Múltipla

Simples: Ex: a = 2

Múltipla: Ex: a, b = “Teste”, 3 -- a recebe o valor “Teste” e b recebe 3 Ex: a, b = “Teste” -- a recebe o valor “Teste” e b recebe nil Ex: a, b = “Teste”, 3, 5 -- a recebe o valor “Teste”, b recebe 3 -- e o valor 5 é desprezado Ex: a, b = b, a -- Troca os valores de a e b entre si

Operadores Aritméticos

São operadores aritméticos de Lua: Soma (+) Subtração (-) Multiplicação (*) Divisão (/) Operador unário de negativo (-) Parênteses podem alterar precedência de operadores. Somente podem ser aplicados a valores do tipo number ou a valores do tipo string que possam ser convertidos para number.

Ex: a = 2 * 3.5 + 4 -- armazena 11 em a b = (a + 1) / “2” -- armazena 6 em b. -- (repare na string “2” convertida para o número 2) c = b * (-3) --armazena -18 em c

Operadores Relacionais

São operadores relacionais de Lua: Menor que (<) Maior que (>) Menor ou igual a (<=) Maior ou igual a (>=) Igual a (==) Diferente de (~=)

Operadores <, >, <=, >= são aplicáveis a number e string.

Operadores == e ~= compara os tipos dos dados (retorna nil caso falso) e, em seguida, os valores. Tabelas, funções e userdata são comparados por referência.

Retornam nil caso falso e 1 caso verdadeiro.

Ex: a = 4 > 3 -- armazena 1 em a b = (a == 2) -- armazena nil em b c = (b == {1}) -- armazena nil em c

Operadores Lógicos

São operadores lógicos de Lua: Conjunção (and) Disjunção (or) Negação (not)

Operadores and e or são avaliados da esquerda para a direita.

Avaliação do tipo curto-circuito (pára ao saber resultado).

Ex: a = 10 b = 20 c = (a < 4) or (b < a) -- armazena nil em c avaliando toda a expressão d = (a < 4) and (b < a) -- armazena nil em d sem precisar avaliar o (b < a)

Operador de Concatenação

É representado por dois caracteres ponto (..).

Aplicável a tipo string , convertendo valores do tipo number quando concatenados a string. Ex: a = “Linguagem” b = “Lua” c = 3. c = a .. “ ” .. b .. c -- armazena “Linguagem Lua 3.2” em c

Estruturas de Controle de Fluxo

Expressões

• Expressões podem retornar qualquer valor de qualquer tipo.
• Sempre que retornar valores diferentes de nil , a expressão é considerada verdadeira.
• Sempre que retornar o valor nil , a expressão é considerada falsa.

Tomada de Decisão

if expr then bloco end

if expr then bloco else bloco end

if expr1 then bloco elseif expr bloco … elseif exprN blocoN else blocoN+ end

Ex: if (a == 5) then print(“a = 5”) end

Ex: if b then print(“b diferente de nil”) else print(“b igual a nil”) end

Ex: if (not a) then print(“a igual a nil”) elseif (a == 1) then print(“a = 1”) else print(“a é maior que 1”) end

Laços Iterativos

Tomada de decisão no começo:

while expr do bloco end

Ex: i = 10 while (i >= 0) do i = i – 1 end Tomada de decisão no fim:

repeat bloco until expr

Ex: i = 10 repeat i = i – 1 until (i == 0)

Não existem laços do tipo for em Lua 3.2.

Veremos ainda na parte de tabelas: foreach e foreachi.

b) i = 1 repeat print(i) i = i + 2 until (i < 11)

c) i = 1 while (i < 11) do print(i) i = i + 2 end

d) i = 1 while (i <= 9) do i = i + 2 print(i) end

Tabelas

• Tabelas em Lua são do tipo de dados table.
• Implementam vetores associativos – valores indexados por qualquer outro tipo (exceto nil ).
• Principal mecanismo de estrutura de dados de Lua.
• Uma variável contém uma referência a uma tabela, e não a própria tabela.
  Designação, passagem de parâmetros e retorno manipulam referências a tabelas, não implicando em cópia
• Tabelas devem ser criadas antes de serem utilizadas

Construtores

Construtores são expressões que criam tabelas.

Construtores podem criar tabelas:

• Vazias: utiliza-se abre e fecha chaves. Ex: a = {}
• Com elementos inicializados indexados numericamente consecutivamente.
• Valores separados por vírgula dentro de chaves.
• O primeiro índice é sempre 1 (e não 0). Ex: b = {1, 3.8, “Teste”} -- nesse caso, b[1] = 1, b[2] = 3.8 e b[3] = “teste”
• Com elementos inicializados indexados por qualquer outro tipo. Ex: c = {c1 = “v1”, c2 = “v2”, [3] = “v3”} -- nesse caso, c[“c1”] = “v1”, c[“c2”] = “v2” e c[3] = “v3”
• Com elementos inicializados indexados das duas formas. Separa-se os dois tipos de indexação com um ponto-e-vírgula. Já os elementos com o mesmo tipo de indexação são separados por vírgula. Ex: d = {1, 3.4; d1 = “x1”, d2 = “x2”, [3] = 8} -- nesse caso, d[1] = 1, d[2] = 3.4, d[“d1”] = “x1”, d[“d2”] = “x2” e d[3] = 8

Após criada a tabela, pode-se armazenar outros valores na tabela, com qualquer tipo de indexação.

Acessando Dados

Para acessar índices numéricos em tabelas, utiliza-se o número entre colchetes.

Ex: a = {1.3, 3.14} print(a[1]) -- imprime 1. print(a[2]) -- imprime 3. a[3] = 12 -- adiciona uma entrada na tabela

Para acessar índices string em tabela, é tanto válido utilizar a string entre aspas e colchetes quanto utilizar a notação com ponto. Desta forma, podem-se simular campos/registros.

Exercícios de Fixação IV

16) Represente em Lua a seguite matriz, em uma tabela t, utilizando somente um constructor.

Imprima também os valores da terceira linha.

17) Represente em Lua os seguinte registros de banco de dados. Primeiramente em uma tabela t utilizando somente um construtor, e em seguida em uma tabela t2, construindo uma tabela vazia e a preenchendo campo a campo.

nome: João da Silva endereco: Rua A, casa B telefone: 2222-

nome: Maria Joaquina endereco: Rua C, casa D telefone: 3333-

nome: Pedro Joaquim endereco: Rua E, casa F telefone: 4444-

18) O que é impresso na tela após a execução do seguinte programa completo em Lua?

a = { } b = 1 c = "b" a[1] = 100 a[c] = 10 a["b"] = a["b"] + 10 a[b] = a[b] + 100 print(a[b]) print(a[c])

Funções

Funções em Lua são do tipo de dados function. É possível armazená-las em variáveis, em índices de tabelas, passá-las como parâmetros para outras funções ou retorná-las como resultados.

Declaração

Duas sintaxes possíveis para declaração: function f(lista-de-parâmetros) bloco end

f = function(lista-de-parâmetros) bloco end

f representa a variável que armazenará a função.

Ex: function soma(a, b) -- é o mesmo que: soma = function(a, b) return a + b end

Lua faz ajuste no número de parâmetros passados à função, completando com nil os parâmetros faltantes. Ex: function func1(a, b, c, d) bloco end

-- chamada da função: func1(1, 2) -- dentro da função: a = 1, b = 2, c = d = nil

-- chamada da função: func1(1, 2, 3, 4, 5, 6) -- dentro da função: a = 1, b = 2, c = 3, d = 4 -- os valores 5 e 6 passados à função são ignorados

• Número variável de argumentos: Ao final da lista de argumentos, adicionar … (três pontos seguidos) Argumentos extras são colocados na tabela implícita arg Ex: function func1(a, b, …) bloco end -- chamada da função: func1(1, 2, 3, 4, 5) -- dentro da função: a = 1, b = 2, arg = {3, 4, 5} -- ou seja, arg[1] = 3, arg[2] = 4, arg[3] = 5
• Passagem de parâmetros por valor Valores do tipo string e number são passados por valor, ou seja, uma cópia local dos mesmos é criada e as variáveis externas não tem seu valor alterado

Ex: function func1(a) a = 1 end