Programação com Lua - Do zero ao mínimo

Uma rápida introdução a linguagem de programação Lua.

lua.org
github.com/jhoonb
dev.to/jhoonb

Transcript

1. Programação com 5.3 quase 5.4 abril 2020 github.com/jhoonb
2. github.com/jhoonb dev.to/jhoonb @jhoonb 5.3 quase 5.4 abril 2020 github.com/jhoonb
3. Do zero ao mínimo 5.3 quase 5.4 abril 2020 github.com/jhoonb
4. todo • • • • ◦ • • ◦ github.com/jhoonb
5. • ◦ • ◦ • • • • • todo github.com/jhoonb
6. Criada em 1993 na Tecgraf (Lançada em 1995) Parceria entre a PUC-RJ + Petrobras. histórico github.com/jhoonb
7. Criada em 1993 na Tecgraf (Lançada em 1995) Parceria entre a PUC-RJ + Petrobras. histórico usada no ambiente onde não existiam programadores profissionais, e sim pessoas de várias áreas para criar scripts. github.com/jhoonb
8. Fonte: Scripting with Lua Roberto Ierusalimschy Curry On 2017 histórico Lua substitui duas pequenas linguagens: DEL e SOL. github.com/jhoonb
9. histórico Foi desenvolvida por Roberto Ierusalimschy (PUC-RJ) Waldemar Celes (PUC-RJ) Luiz Henrique de Figueiredo (IMPA) github.com/jhoonb
10. histórico Waldemar, Roberto, Luiz · photo by Ernani d'Almeida (2011) github.com/jhoonb
11. histórico Lançada em 1995: Licença Open Source: MIT license. O núcleo da linguagem é totalmente escrito e mantido pelo comitê composto por Waldemar, Roberto e Luiz. Não são aceitos patches e correções de terceiros, bugs podem ser reportados porém códigos são escritos exclusivamente pelo comitê. github.com/jhoonb
12. histórico Aplicação inesperada: jogos começaram a adotar Lua como linguagem de script e em poucos anos Lua se tornou a principal ferramenta no desenvolvimento de Jogos no mundo. github.com/jhoonb
13. Casos de Uso Fonte: Scripting with Lua Roberto Ierusalimschy Curry On 2017 github.com/jhoonb
14. Casos de Uso Fonte: Errâncias de um Software Brasileiro Roberto Ierusalimschy github.com/jhoonb
15. Casos de Uso Em grandes projetos de software também: Fonte: Scripting with Lua Roberto Ierusalimschy Curry On 2017 github.com/jhoonb
16. Casos de Uso fonte: Why (and why not) Lua? Roberto Ierusalimschy github.com/jhoonb
17. histórico Em 2007 Lua foi apresentada na History of Programming Languages (HOPL III), 3a Conferência da ACM sobre a História das Linguagens de Programação, tendo importância global. Essa conferência ocorre a cada 15 anos. Lua é a única linguagem criada fora do primeiro mundo com reconhecimento e importância mundial. github.com/jhoonb
18. histórico Atualmente Lua está na versão 5.3 (a versão 5.4 está quase pronta) github.com/jhoonb
19. características • Escrita em C ANSI • Tipagem dinâmica • Tipagem Forte (+-) • Coerção • Possui 22 palavras reservadas • Standard Library pequena, mas eficiente • 8 tipos de dados primitivos • todos os valores são first-class-value • única estrutura de dados (table) • Case sensitive • namespace (usando table) github.com/jhoonb
20. características • Módulos (usando table) • Objetos (usando table) • Multiplataforma • Embutível e extensível • Linguagem interpretada • Virtual Machine baseada em registradores • Possui Garbage Collector • Procedural • Múltiplo retorno de funções • co-rotinas github.com/jhoonb
21. características Lua é: • Rápida e Portátil: pequeno pacote que compila sem modificações em todas as plataformas que têm um compilador C padrão; • Embutível: API em C, simples e bem documentada + Meta-mecanismos; • Pequena e Livre: código-fonte + documentação: 297K comprimido e 1.2M descompactado. 24000 linhas de C; licença MIT; github.com/jhoonb
22. Instalação / editor / IDE Windows? Linux? Mac? Lua.org/start online/web: lua demo IDE? ZeroBrane Studio. Completo com exemplos. Editor? Sublime Text 3, VSCode, micro, vim, Notepad ++ escolha pessoal github.com/jhoonb
23. Tipos Primitivos: atribuição atribuição variavel = valor github.com/jhoonb
24. Tipos Primitivos: atribuição atribuição variavel = valor nome para a variável, pode ser _ (underscore), letras e números, só não pode começar com número. github.com/jhoonb
25. Tipos Primitivos: atribuição atribuição variavel = valor operador igual (=) é de atribuição github.com/jhoonb
26. Tipos Primitivos: atribuição atribuição variavel = valor só valores possuem tipos! github.com/jhoonb
27. Tipos Primitivos: atribuição atribuição variavel = valor number string table function thread userdata nil github.com/jhoonb
28. Tipos Primitivos 8 tipos básicos, são eles: number: único tipo numérico string: cadeia de caracteres table: única estrutura de dados function: armazena funções thread: para implementar co-rotinas userdata: armazena dados oriundos de programas em C nil: valor indefinido boolean: valor booleano github.com/jhoonb
29. Tipos Primitivos number: representa tanto números inteiros (integer)quanto números reais(floating-point). O tipo number usa duas representações internas, ou dois subtypes: int e float, por padrão os dois 64-bit number github.com/jhoonb
30. Tipos Primitivos x = 2 x = 1000 x = 986.789 x = 567890.9 x = 4.57e-3 x = 0.3e12 x = 5e+20 number github.com/jhoonb
31. Tipos Primitivos x = 2 x = 1000 x = 986.789 x = 567890.9 x = 4.57e-3 x = 0.3e12 x = 5e+20 usamos . (ponto) para números reais number github.com/jhoonb
32. Tipos Primitivos x = 2 x = 1000 x = 986.789 x = 567890.9 x = 4.57e-3 x = 0.3e12 x = 5e+20 notação científica number github.com/jhoonb
33. Tipos Primitivos string: (Cadeia de caracteres), tipo imutável str1 = ‘linguagem ’ str2 = “Lua” str3 = [[teste de strings]] nome = str1 .. str2 string github.com/jhoonb
34. Tipos Primitivos string: (Cadeia de caracteres), tipo imutável str1 = ‘linguagem ’ str2 = “Lua” str3 = [[teste de strings]] nome = str1 .. str2 aspas simples aspas duplas string github.com/jhoonb
35. Tipos Primitivos string: (Cadeia de caracteres), tipo imutável str1 = ‘linguagem ’ str2 = “Lua” str3 = [[teste de strings]] nome = str1 .. str2 [[ ]] para múltiplas linhas string github.com/jhoonb
36. Tipos Primitivos string: (Cadeia de caracteres), tipo imutável str1 = ‘linguagem ’ str2 = “Lua” str3 = [[teste de strings]] nome = str1 .. str2 concatenar string operador próprio .. string github.com/jhoonb
37. boolean: valor booleano/lógico true ou false. var = true var = false Tipos Primitivos boolean github.com/jhoonb
38. boolean: valor booleano/lógico true ou false. var = true var = false Tipos Primitivos qualquer valor exceto false e nil são verdadeiros. boolean github.com/jhoonb
39. Tipos Primitivos function: definindo funções soma = function(a, b) return a + b end function soma(a, b) return a + b end soma(2, 3) --> 5 function github.com/jhoonb
40. Tipos Primitivos function: definindo funções soma = function(a, b) return a + b end function soma(a, b) return a + b end soma(2, 3) --> 5 variável soma recebe uma função anônima com dois parâmetros, que retorna a soma deles. function github.com/jhoonb
41. Tipos Primitivos function: definindo funções soma = function(a, b) return a + b end function soma(a, b) return a + b end soma(2, 3) --> 5 Açúcar sintático* para escrever a mesma função *syntax sugar function github.com/jhoonb
42. Tipos Primitivos function: definindo funções soma = function(a, b) return a + b end function soma(a, b) return a + b end soma(2, 3) --> 5 Funções são Valores de Primeira Classe (First Class Value). E são anônimas. function github.com/jhoonb
43. Tipos Primitivos function: definindo funções soma = function(a, b) return a + b end function soma(a, b) return a + b end f = soma f(2, 3) --> 5 Podem ser valores de variáveis function github.com/jhoonb
44. Tipos Primitivos function: definindo funções soma = function(a, b) return a + b end sub = function(a, b) return a - b end soma_sub = function(f1, f2, a, b) return f1(a, b), f2(a, b) end a, b = soma_sub(soma, sub, 10, 15) function github.com/jhoonb
45. Tipos Primitivos function: definindo funções soma = function(a, b) return a + b end sub = function(a, b) return a - b end soma_sub = function(f1, f2, a, b) return f1(a, b), f2(a, b) end a, b = soma_sub(soma, sub, 10, 15) podemos passar funções como parâmetros function github.com/jhoonb
46. Tipos Primitivos function: definindo funções soma = function(a, b) return a + b end sub = function(a, b) return a - b end soma_sub = function(f1, f2, a, b) return f1(a, b), f2(a, b) end a, b = soma_sub(soma, sub, 10, 15) podemos passar funções como argumentos de funções function github.com/jhoonb
47. Tipos Primitivos function: definindo funções soma = function(a, b) return a + b end sub = function(a, b) return a - b end soma_sub = function(f1, f2, a, b) return f1(a, b), f2(a, b) end a, b = soma_sub(soma, sub, 10, 15) podemos chamar as funções function github.com/jhoonb
48. Tipos Primitivos function: definindo funções soma = function(a, b) return a + b end sub = function(a, b) return a - b end soma_sub = function(f1, f2, a, b) return f1(a, b), f2(a, b) end a, b = soma_sub(soma, sub, 10, 15) múltiplos retornos function github.com/jhoonb
49. Tipos Primitivos function: definindo funções soma = function(a, b) return a + b end sub = function(a, b) return a - b end soma_sub = function(f1, f2, a, b) return f1(a, b), f2(a, b) end a, b = soma_sub(soma, sub, 10, 15) múltiplos retornos passados paras as variáveis function github.com/jhoonb
50. Tipos Primitivos table: tabelas (array associativo) t = {} t = {10, 20, “Lua”} t[1] --> 10 t[3] --> “Lua” t = {a = 1, b = 2, c = ‘lua’} t[‘a’] --> 1 table github.com/jhoonb
51. Tipos Primitivos table: tabelas (array associativo) t = {} t = {10, 20, “Lua”} t[1] --> 10 t[3] --> “Lua” t = {a = 1, b = 2, c = ‘lua’} t[‘a’] --> 1 cria uma tabela vazia usamos chaves table github.com/jhoonb
52. Tipos Primitivos table: tabelas (array associativo) t = {} t = {10, 20, “Lua”} t[1] --> 10 t[3] --> “Lua” t = {a = 1, b = 2, c = ‘lua’} t[‘a’] --> 1 podemos usar como uma lista table github.com/jhoonb
53. Tipos Primitivos table: tabelas (array associativo) t = {} t = {10, 20, “Lua”} t[1] --> 10 t[3] --> “Lua” t = {a = 1, b = 2, c = ‘lua’} t[‘a’] --> 1 acessamos os valores da tabela através de índices table github.com/jhoonb
54. Tipos Primitivos table: tabelas (array associativo) t = {} t = {10, 20, “Lua”} t[1] --> 10 t[3] --> “Lua” t = {a = 1, b = 2, c = ‘lua’} t[‘a’] --> 1 índices em Lua começam em 1, não em 0 como em Python ou C table github.com/jhoonb
55. Tipos Primitivos table: tabelas (array associativo) t = {} t = {10, 20, “Lua”} t[1] --> 10 t[3] --> “Lua” t = {a = 1, b = 2, c = ‘lua’} t[‘a’] --> 1 usamos tabela como array associativo, ou dicionário (Python) conjunto não-ordenado de pares chave=valor table github.com/jhoonb
56. Tipos Primitivos table: tabelas (array associativo) t = {a = 1, b = 2, c = ‘lua’} t[‘b’] --> 2 acessamos o valor passando a chave para a tabela table github.com/jhoonb
57. Tipos Primitivos table: tabelas (array associativo) t = {a = 1, b = 2, c = ‘lua’} t[‘b’] --> 2 t.b --> 2 açúcar sintático* para acessar o valor, usando a chave *syntax sugar table github.com/jhoonb
58. Tipos Primitivos table: tabelas (array associativo) t = {a = 1, b = 2, c = ‘lua’} t = {} t.a = 1 t.b = 2 t.c = ‘lua’ as duas formas de construir tabelas são equivalentes table github.com/jhoonb
59. Tipos Primitivos table: tabelas (array associativo) soma = function(a, b) return a + b end t = {a = 1, b = {a = “Lua”}, f = soma} tabelas podem armazenar tabelas e funções table github.com/jhoonb
60. Tipos Primitivos table: tabelas (array associativo) soma = function(a, b) return a + b end t = {a = 1, b = {a = “Lua”}, f = soma} t.b.a --> “Lua” t[“b”][“a”] --> “Lua” t[“b”].a --> “Lua” t.b[“a”] --> “Lua” acessando a tabela dentro da tabela table github.com/jhoonb
61. Tipos Primitivos table: tabelas (array associativo) soma = function(a, b) return a + b end t = {a = 1, b = {a = “Lua”}, f = soma} t.f t[“f”] acessando a função table github.com/jhoonb
62. Tipos Primitivos table: tabelas (array associativo) soma = function(a, b) return a + b end t = {a = 1, b = {a = “Lua”}, f = soma} t.f --> function: 0x559e12e985f0 t[“f”] --> function: 0x559e12e985f0 retorna a referência pra função table github.com/jhoonb
63. Tipos Primitivos table: tabelas (array associativo) soma = function(a, b) return a + b end t = {a = 1, b = {a = “Lua”}, f = soma} t.f(2,4) --> 6 t[“f”](2,4) → 6 para executar a função, chamamos com parênteses e passamos os parâmetros table github.com/jhoonb
64. Tipos Primitivos table: tabelas (array associativo) heroi = {} heroi.nome = “Pio X” heroi.velocidade = 100 heroi.ataque = 100 criamos registros table github.com/jhoonb
65. Tipos Primitivos table: tabelas (array associativo) retangulo = {} retangulo.x = 100 retangulo.y = 70 retangulo.altura = 330 retangulo.largura = 100 criamos registros table github.com/jhoonb
66. userdata: permite que dados em C possam ser armazenados em variáveis Lua. Este tipo corresponde a um bloco de memória e não tem operações pré-definidas em Lua. Valores userdata não podem ser criados ou modificados em Lua, somente através da API C. ex.: type(io.input()) --> userdata Tipos Primitivos userdata github.com/jhoonb
67. thread: O tipo thread representa fluxos de execução independentes e é usado para implementar co-rotinas. Tipos Primitivos thread github.com/jhoonb
68. thread: O tipo thread representa fluxos de execução independentes e é usado para implementar co-rotinas. c = coroutine.create(function() print(“Lua”) end ) type(c) --> thread Tipos Primitivos thread github.com/jhoonb
69. Tipos Primitivos nil é o null (nulo) de Lua, sua característica é ser um valor diferente de qualquer outro. nil github.com/jhoonb
70. Palavras reservadas and break do else elseif end false for function goto if in local nil not or repeat return then true until while github.com/jhoonb
71. Palavras reservadas Lua possui apenas 22 palavras reservadas keywords Java = 51 C = 32 C++ = 60 Javascript = 33 Python = 33 Go = 25 Cobol = 300 github.com/jhoonb
72. Itens Léxicos: outros tokens + - * / % ^ # & ~ | << >> // == ~= <= >= < > = ( ) { } [ ] :: ; : , . .. ... github.com/jhoonb
73. Operadores github.com/jhoonb
74. Operadores: lógicos descrição operador exemplo e (conjunção) and a and b ou (disjunção inclusiva) or a or b não (negado) not not a github.com/jhoonb
75. Operadores Lógicos: true and true --> true true and false --> false false and true --> false false and false --> false true or true --> true true or false --> true false or true --> true false or false --> false github.com/jhoonb
76. Operadores Lógicos: true and true --> true true and false --> false false and true --> false false and false --> false true or true --> true true or false --> true false or true --> true false or false --> false operador binário: and retorna true se os dos valores são true github.com/jhoonb
77. Operadores Lógicos: true and true --> true true and false --> false false and true --> false false and false --> false true or true --> true true or false --> true false or true --> true false or false --> false operador binário: or retorna true se ao menos 1 dos valores é true github.com/jhoonb
78. Operadores Lógicos: not true --> false not false --> true operador unário: not troca o valor lógico github.com/jhoonb
79. Operadores Lógicos: not true --> false not false --> true operador unário: not troca o valor lógico nega o true -> false github.com/jhoonb
80. Operadores Lógicos: not true --> false not false --> true operador unário: not troca o valor lógico nega o false -> true github.com/jhoonb
81. Operadores: relacionais descrição operador exemplo igualdade == a == a desigualdade(diferente) ~= a ~= b menor que < a < b maior que > a > b menor ou igual <= a <= b maior ou igual >= a >= b github.com/jhoonb
82. Operadores: matemáticos 2 + 3 --> 5 2 - 3 --> -1 2 * 3 --> 6 2 / 3 --> 0.66666666666667 2 // 3 --> 0 2 ^ 3 --> 8.0 2 % 3 --> 2 -2 --> -2 github.com/jhoonb
83. Operadores: matemáticos 2 + 3 --> 5 2 - 3 --> -1 2 * 3 --> 6 2 / 3 --> 0.66666666666667 2 // 3 --> 0 2 ^ 3 --> 8.0 2 % 3 --> 2 -2 --> -2 adição github.com/jhoonb
84. Operadores: matemáticos 2 + 3 --> 5 2 - 3 --> -1 2 * 3 --> 6 2 / 3 --> 0.66666666666667 2 // 3 --> 0 2 ^ 3 --> 8.0 2 % 3 --> 2 -2 --> -2 subtração github.com/jhoonb
85. Operadores: matemáticos 2 + 3 --> 5 2 - 3 --> -1 2 * 3 --> 6 2 / 3 --> 0.66666666666667 2 // 3 --> 0 2 ^ 3 --> 8.0 2 % 3 --> 2 -2 --> -2 multiplicação github.com/jhoonb
86. Operadores: matemáticos 2 + 3 --> 5 2 - 3 --> -1 2 * 3 --> 6 2 / 3 --> 0.66666666666667 2 // 3 --> 0 2 ^ 3 --> 8.0 2 % 3 --> 2 -2 --> -2 divisão real github.com/jhoonb
87. Operadores: matemáticos 2 + 3 --> 5 2 - 3 --> -1 2 * 3 --> 6 2 / 3 --> 0.66666666666667 2 // 3 --> 0 2 ^ 3 --> 8.0 2 % 3 --> 2 -2 --> -2 divisão inteira github.com/jhoonb
88. Operadores: matemáticos 2 + 3 --> 5 2 - 3 --> -1 2 * 3 --> 6 2 / 3 --> 0.66666666666667 2 // 3 --> 0 2 ^ 3 --> 8.0 2 % 3 --> 2 -2 --> -2 exponenciação github.com/jhoonb
89. Operadores: matemáticos 2 + 3 --> 5 2 - 3 --> -1 2 * 3 --> 6 2 / 3 --> 0.66666666666667 2 // 3 --> 0 2 ^ 3 --> 8.0 2 % 3 --> 2 -2 --> -2 módulo (resto da divisão inteira) github.com/jhoonb
90. Operadores: matemáticos 2 + 3 --> 5 2 - 3 --> -1 2 * 3 --> 6 2 / 3 --> 0.66666666666667 2 // 3 --> 0 2 ^ 3 --> 8.0 2 % 3 --> 2 -2 --> -2 negativo (operador unário) github.com/jhoonb
91. Estrutura de Controle github.com/jhoonb
92. Estrutura de Controle código é qualquer expressão em lua que retorne um valor boolean (lógico) true ou false github.com/jhoonb
93. Estrutura de Controle código é qualquer expressão em lua que retorne um valor boolean (lógico) true ou false github.com/jhoonb
94. Estrutura de Controle bloco-de-código código lua github.com/jhoonb
95. Estrutura de Controle bloco-de-código código lua github.com/jhoonb
96. Estrutura de Controle expressões podem ser escritas na mesma linha, separando-as por ; ou espaços (padrão em Lua) github.com/jhoonb
97. Estrutura de Controle SEMPRE se termina uma condição com a palavra reservada end github.com/jhoonb
98. Estrutura de Controle github.com/jhoonb
99. Estrutura de Controle elseif é obrigatório que tenha condição github.com/jhoonb
100. Estrutura de Controle else não é obrigatório, mas é uma boa prática github.com/jhoonb
101. Estrutura de Controle github.com/jhoonb
102. Estrutura de Controle expressão precisa ser verdadeira para continuar executando o loop, quando a expressão for falsa, se encerra o loop github.com/jhoonb
103. Estrutura de Controle nossa expressão de condição: enquanto i for menor igual a 5 faça (continue executando o bloco-de-código) github.com/jhoonb
104. Estrutura de Controle saída: 1 1 1 1 1 ... Por que o loop continua infinitamente? github.com/jhoonb
105. Estrutura de Controle saída: 1 1 1 1 1 ... Porque a condição nunca muda: x continua sendo 1 infinitamente, a não ser que você troque. Precisamos incrementar nossa variável da condição, explicitamente github.com/jhoonb
106. Estrutura de Controle saída: 1 2 3 4 5 x = x + 1 em cada passo do loop, é somado 1 ao valor total de x github.com/jhoonb
107. Estrutura de Controle repeat bloco-de-código until exp repeat-until executa primeiro o bloco-de-código depois verifica a exp essa forma de loop a exp deve ser falsa para continuar executando, quando ela for verdadeira o loop é encerrado github.com/jhoonb
108. Estrutura de Controle n = 5 repeat print(n) n = n + 1 until n > 10 5 6 7 8 9 10 github.com/jhoonb
109. Estrutura de Controle for exp1, exp2, exp3 do bloco-de-código end github.com/jhoonb
110. Estrutura de Controle for exp1, exp2, exp3 do bloco-de-código end no for, executa o loop de exp1 até exp2 usando o passo (step) exp3, por padrão exp3 assume 1 e pode ser omitida github.com/jhoonb
111. Estrutura de Controle for i = 1, 10, 1 do print(i) end “para variável i de 1 até 10 em 1 em 1 faça.” github.com/jhoonb
112. Estrutura de Controle for i = 1, 10 do print(i) end exp3, pode ser omitida github.com/jhoonb
113. Estrutura de Controle for i = 1, 10 do print(i) end exp3, pode ser omitida 1 2 3 4 5 6 7 8 9 10 github.com/jhoonb
114. Estrutura de Controle for i = 1, 10 do print(i) end resultado 1 2 3 4 5 6 7 8 9 10 github.com/jhoonb
115. Estrutura de Controle for i = 1, 10 do print(i) end diferente do while, no loop for não precisamos incrementar a variável explicitamente 1 2 3 4 5 6 7 8 9 10 github.com/jhoonb
116. Estrutura de Controle for i = 10, 1, -1 do print(i) end podemos usar negativo, para percorrer do fim ao começo 10 9 8 7 6 5 4 3 2 1 github.com/jhoonb
117. Estrutura de Controle for i = 1, #lista do print(lista[i]) end operador # retorna o tamanho de uma tabela (quando essa é usada como um array) github.com/jhoonb
118. Estrutura de Controle ipairs pairs for i, v in ipairs(t) do print(i, v) end for k, v in pairs(t) do print(k, v) end github.com/jhoonb
119. Estrutura de Controle for i, v in ipairs(lista) do print(i, v) end no for genérico, usamos a keyword in e duas variáveis: i = será o índice da lista v = o valor ipairs() é uma função que pega uma tabela e retorna pares de índice-valor (i,v) de maneira iterável github.com/jhoonb
120. Estrutura de Controle for i, v in ipairs(lista) do print(i, v) end no for genérico, usamos a keyword in e duas variáveis: i = será o índice da lista v = o valor ipairs() é uma função que pega uma tabela e retorna pares de índice-valor (i,v) de maneira iterável saída: 1 10 2 20 3 30 github.com/jhoonb
121. Estrutura de Controle for k, v in pairs(aluno) do print(k, v) end Para iterar sobre um array associativo, conjunto não-ordenado de chave-valor, usamos pairs() github.com/jhoonb
122. Estrutura de Controle for k, v in pairs(aluno) do print(k, v) end saída: idade 18 codigo 30912 nome Bento github.com/jhoonb
123. Estrutura de Controle github.com/jhoonb
124. Estrutura de Controle for i = 10, 1, -1 do print(i) break end while true do print(“Lua”); break end repeat print(“Lua”) break until false github.com/jhoonb
125. Estrutura de Controle for i = 10, 1, -1 do print(i) break end while true do print(“Lua”); break end repeat print(“Lua”) break until false github.com/jhoonb
126. Detalhes • Lua • Lua • • github.com/jhoonb
127. Detalhes: escopo • github.com/jhoonb
128. Detalhes: escopo github.com/jhoonb
129. Detalhes: keyword local github.com/jhoonb
130. Detalhes: keyword local Escopo global Escopo local Escopo local for, while, repeat, do, function for, while, repeat, do, function módulo, for, while, repeat, do, function github.com/jhoonb
131. Detalhes: keyword local github.com/jhoonb
132. Detalhes: keyword local alteramos o valor de a, que foi acessado do escopo global github.com/jhoonb
133. Detalhes: keyword local criamos uma variável a dentro do escopo local da função. Não alterou a variável a do escopo global github.com/jhoonb
134. Detalhes: keyword local diferentes maneiras de escrever a mesma função github.com/jhoonb
135. Detalhes: keyword local diferentes maneiras de escrever a mesma função com escopo local local github.com/jhoonb
136. Detalhes: keyword local local github.com/jhoonb
137. funções básicas Toda linguagem de programação fornece um conjunto de bibliotecas (funções) que estão disponíveis por padrão. A Biblioteca padrão de Lua é implementada diretamente por uma API em C, e é pequena, enxuta, porém, eficiente. github.com/jhoonb
138. funções básicas imprime os dados print(...) se v == false or nil gera erro e retorna a mensagem assert(v, [mensagem]) executa o arquivo Lua externo dofile([filename]) github.com/jhoonb
139. funções básicas converte e retorna string para tipo number tonumber(string) converte e retorna number pra tipo string tostring(number) retorna o tipo de v. (string) type(v) github.com/jhoonb
140. funções básicas retorna o tamanho de uma string ou table (retorna valor number) #t variável, retorna a versão corrente de Lua _VERSION github.com/jhoonb
141. funções básicas tabela global que contém todos as funções de Lua _G recebe dados via teclado (usa módulo io) io.read() carrega o módulo ‘filename’.lua require(‘filename’) github.com/jhoonb
142. funções básicas retorna dois valores primeiro o índice e outro o valor pairs(t) retorna dois valores o primeiro a chave e outro o valor (sem ordem específica) ipairs(t) github.com/jhoonb
143. funções básicas • basic library • coroutine library • package library • string manipulation • basic UTF-8 support • table manipulation • mathematical functions • input and output • operating system facilities • debug facilities github.com/jhoonb
144. do mínimo ao básico github.com/jhoonb
145. Exercícios github.com/jhoonb/lua-exemplos github.com/jhoonb
146. Referências • • https://www.lua.org/manual/5.3/ • https://dev.to/jhoonb/introducao-a-linguagem -de-programacao-lua-1aoi github.com/jhoonb
147. lua.org lua.inf.puc-rio.br github.com/jhoonb