Aprenda Lua em 15 minutos

-- Dois traços começam um comentário de uma linha. --[[ Adicionando dois ['s e ]'s torna um comentário em várias linhas. --]] ---------------------------------------------------- -- 1. Variáveis e controle de fluxo. ---------------------------------------------------- num = 42 -- Todos os números são duplos. -- Não freak out, 64-bit duplos têm 52 bits -- para armazenamento de valores int exatos; -- a precisão da máquina não é um problema -- para as pessoas que precisam < 52 bits. s = 'walternate' -- Strings imutáveis como no Python. t = "Aspas duplas também são boas" u = [[ Colchetes duplos Começar e terminar strings de várias linhas. ]] t = nil -- Indefinido t; Em LUA é uma garbage collection. -- Os blocos são denotados com palavras-chave como -- fazer/terminar (do/end): while num < 50 do num = num + 1 -- Não ++ ou += operadores de tipo. end -- Cláusulas em If : if num > 40 then print('Acima de 40') elseif s ~= 'walternate' then -- ~= não é igual. -- A verificação da igualdade é == como no Python; -- ok para strings. io.write('Não é mais de 40\n') -- Padrão para stdout. else -- As variáveis são globais por padrão. thisIsGlobal = 5 -- Camelcase é comum. -- Como fazer uma variável local: local line = io.read() -- Lê a próxima linha de stdin. -- A concatenação de string usa o operador '..' : print('O inverno está chegando, ' .. line) end -- Variáveis indefinidas retornam nil. -- isso não é um erro: foo = anUnknownVariable -- Agora, foo = nil. aBoolValue = false -- Apenas nil e falsas são falsas; 0 e '' são verdadeiras! if not aBoolValue then print('é falso') end -- 'or' e 'and' estão em curto-circuito (short-circuited). -- Isso é semelhante ao a?b:c operador em C/JS: ans = aBoolValue and 'yes' or 'no' --> 'no' -- O intervalo inclui ambas as extremidades. karlSum = 0 for i = 1, 100 do karlSum = karlSum + i end -- Usar "100, 1, -1" como o intervalo para -- contar para baixo: fredSum = 0 for j = 100, 1, -1 do fredSum = fredSum + j end -- Em geral, o alcance é begin, end[, step]. -- Outra construção de loop: repeat print('Asterisk o Futuro da Telefonia') num = num - 1 until num == 0 ---------------------------------------------------- -- 2. Funções (Functions). ---------------------------------------------------- function fib(n) if n < 2 then return 1 end return fib(n - 2) + fib(n - 1) end -- Fechamentos e funções anônimas estão ok: function adder(x) -- A função retornada é criada quando o somador é -- chamado e lembra o valor de x: return function (y) return x + y end end a1 = adder(9) a2 = adder(36) print(a1(16)) --> 25 print(a2(64)) --> 100 -- Retorno, funcões de chamadas e atribuições, -- todos funcionam com listas que podem ser -- incompatíveis. Os receptores incomparáveis -- são nulos (nil); remetentes incomparáveis -- são descartados. x, y, z = 1, 2, 3, 4 -- Agora, x = 1, y = 2, z = 3, e 4 é jogado fora. function bar(a, b, c) print(a, b, c) return 4, 8, 15, 16, 23, 42 end x, y = bar('zaphod') --> imprime "zaphod nil nil" -- Agora, x = 4, y = 8, valores 15..42 são descartados. -- As funções são de primeira classe, podem ser -- locais/globais. Estes são os mesmos (same): function f(x) return x * x end f = function (x) return x * x end -- E assim são estes: local function g(x) return math.sin(x) end local g; g = function (x) return math.sin(x) end -- O declaração 'local g' faz referência a -- g-self-references ok. -- As funções Trig funcionam em radianos, a propósito. -- As chamadas com uma string de parametro, não precisam -- de parentes: print 'Eu voltarei!' -- Funciona bem. ---------------------------------------------------- -- 3. Tabelas. ---------------------------------------------------- -- Tables = Lua's only compound data structure; -- they are associative arrays. -- Similar to php arrays or js objects, they are -- hash-lookup dicts that can also be used as lists. -- Using tables as dictionaries / maps: -- Dict literals have string keys by default: t = {key1 = 'value1', key2 = false} -- String keys can use js-like dot notation: print(t.key1) -- Prints 'value1'. t.newKey = {} -- Adds a new key/value pair. t.key2 = nil -- Removes key2 from the table. -- Literal notation for any (non-nil) value as key: u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'} print(u[6.28]) -- prints "tau" -- Key matching is basically by value for numbers -- and strings, but by identity for tables. a = u['@!#'] -- Now a = 'qbert'. b = u[{}] -- We might expect 1729, but it's nil: -- b = nil since the lookup fails. It fails -- because the key we used is not the same object -- as the one used to store the original value. So -- strings & numbers are more portable keys. -- A one-table-param function call needs no parens: function h(x) print(x.key1) end h{key1 = 'Sonmi~451'} -- Prints 'Sonmi~451'. for key, val in pairs(u) do -- Table iteration. print(key, val) end -- _G is a special table of all globals. print(_G['_G'] == _G) -- Prints 'true'. -- Using tables as lists / arrays: -- List literals implicitly set up int keys: v = {'value1', 'value2', 1.21, 'gigawatts'} for i = 1, #v do -- #v is the size of v for lists. print(v[i]) -- Indices start at 1 !! SO CRAZY! end -- A 'list' is not a real type. v is just a table -- with consecutive integer keys, treated as a list. ---------------------------------------------------- -- 3.1 Metatables and metamethods. ---------------------------------------------------- -- A table can have a metatable that gives the table -- operator-overloadish behavior. Later we'll see -- how metatables support js-prototypey behavior. f1 = {a = 1, b = 2} -- Represents the fraction a/b. f2 = {a = 2, b = 3} -- This would fail: -- s = f1 + f2 metafraction = {} function metafraction.__add(f1, f2) sum = {} sum.b = f1.b * f2.b sum.a = f1.a * f2.b + f2.a * f1.b return sum end setmetatable(f1, metafraction) setmetatable(f2, metafraction) s = f1 + f2 -- call __add(f1, f2) on f1's metatable -- f1, f2 have no key for their metatable, unlike -- prototypes in js, so you must retrieve it as in -- getmetatable(f1). The metatable is a normal table -- with keys that Lua knows about, like __add. -- But the next line fails since s has no metatable: -- t = s + s -- Class-like patterns given below would fix this. -- An __index on a metatable overloads dot lookups: defaultFavs = {animal = 'gru', food = 'donuts'} myFavs = {food = 'pizza'} setmetatable(myFavs, {__index = defaultFavs}) eatenBy = myFavs.animal -- works! thanks, metatable -- Direct table lookups that fail will retry using -- the metatable's __index value, and this recurses. -- An __index value can also be a function(tbl, key) -- for more customized lookups. -- Values of __index,add, .. are called metamethods. -- Full list. Here a is a table with the metamethod. -- __add(a, b) for a + b -- __sub(a, b) for a - b -- __mul(a, b) for a * b -- __div(a, b) for a / b -- __mod(a, b) for a % b -- __pow(a, b) for a ^ b -- __unm(a) for -a -- __concat(a, b) for a .. b -- __len(a) for #a -- __eq(a, b) for a == b -- __lt(a, b) for a < b -- __le(a, b) for a <= b -- __index(a, b) for a.b -- __newindex(a, b, c) for a.b = c -- __call(a, ...) for a(...) ---------------------------------------------------- -- 3.2 Class-like tables and inheritance. ---------------------------------------------------- -- Classes aren't built in; there are different ways -- to make them using tables and metatables. -- Explanation for this example is below it. Dog = {} -- 1. function Dog:new() -- 2. newObj = {sound = 'woof'} -- 3. self.__index = self -- 4. return setmetatable(newObj, self) -- 5. end function Dog:makeSound() -- 6. print('I say ' .. self.sound) end mrDog = Dog:new() -- 7. mrDog:makeSound() -- 'I say woof' -- 8. -- 1. Dog acts like a class; it's really a table. -- 2. function tablename:fn(...) is the same as -- function tablename.fn(self, ...) -- The : just adds a first arg called self. -- Read 7 & 8 below for how self gets its value. -- 3. newObj will be an instance of class Dog. -- 4. self = the class being instantiated. Often -- self = Dog, but inheritance can change it. -- newObj gets self's functions when we set both -- newObj's metatable and self's __index to self. -- 5. Reminder: setmetatable returns its first arg. -- 6. The : works as in 2, but this time we expect -- self to be an instance instead of a class. -- 7. Same as Dog.new(Dog), so self = Dog in new(). -- 8. Same as mrDog.makeSound(mrDog); self = mrDog. ---------------------------------------------------- -- Inheritance example: LoudDog = Dog:new() -- 1. function LoudDog:makeSound() s = self.sound .. ' ' -- 2. print(s .. s .. s) end seymour = LoudDog:new() -- 3. seymour:makeSound() -- 'woof woof woof' -- 4. -- 1. LoudDog gets Dog's methods and variables. -- 2. self has a 'sound' key from new(), see 3. -- 3. Same as LoudDog.new(LoudDog), and converted to -- Dog.new(LoudDog) as LoudDog has no 'new' key, -- but does have __index = Dog on its metatable. -- Result: seymour's metatable is LoudDog, and -- LoudDog.__index = LoudDog. So seymour.key will -- = seymour.key, LoudDog.key, Dog.key, whichever -- table is the first with the given key. -- 4. The 'makeSound' key is found in LoudDog; this -- is the same as LoudDog.makeSound(seymour). -- If needed, a subclass's new() is like the base's: function LoudDog:new() newObj = {} -- set up newObj self.__index = self return setmetatable(newObj, self) end ---------------------------------------------------- -- 4. Modules. ---------------------------------------------------- --[[ I'm commenting out this section so the rest of -- this script remains runnable. -- Suppose the file mod.lua looks like this: local M = {} local function sayMyName() print('Hrunkner') end function M.sayHello() print('Why hello there') sayMyName() end return M -- Another file can use mod.lua's functionality: local mod = require('mod') -- Run the file mod.lua. -- require is the standard way to include modules. -- require acts like: (if not cached; see below) local mod = (function () end)() -- It's like mod.lua is a function body, so that -- locals inside mod.lua are invisible outside it. -- This works because mod here = M in mod.lua: mod.sayHello() -- Says hello to Hrunkner. -- This is wrong; sayMyName only exists in mod.lua: mod.sayMyName() -- error -- require's return values are cached so a file is -- run at most once, even when require'd many times. -- Suppose mod2.lua contains "print('Hi!')". local a = require('mod2') -- Prints Hi! local b = require('mod2') -- Doesn't print; a=b. -- dofile is like require without caching: dofile('mod2.lua') --> Hi! dofile('mod2.lua') --> Hi! (runs it again) -- loadfile loads a lua file but doesn't run it yet. f = loadfile('mod2.lua') -- Call f() to run it. -- loadstring is loadfile for strings. g = loadstring('print(343)') -- Returns a function. g() -- Prints out 343; nothing printed before now. --]] ---------------------------------------------------- -- 5. Referências. ---------------------------------------------------- --[[ Eu estava ansioso para aprender Lua para que eu pudesse fazer jogos como Löve 2D game engine. Esse é o porquê. Comecei com BlackBulletIV's Lua for programmers. Em seguida li o oficial Programming in Lua book. É assim que é os caminhos das pedras. Pode ser útil verificar o Lua short referência em lua-users.org. Os principais tópicos não abordados são bibliotecas padrão: * string library * table library * math library * io library * os library Por sinal, este arquivo completo é válido Lua; Salve isso Como learn.lua e execute com "lua learn.lua" ! Isto foi escrito pela primeira vez para tylerneylon.com. Também está disponível como um github gist. Tutoriais para outras línguas, no mesmo estilo que este, estão aqui: http://learnxinyminutes.com/ Divirta-se com LUA! --]]
Share:

0 comentários:

Aviso importante!

Não realizamos upload dos ficheiros, apenas reportamos os links que encontramos na própria Internet. Assim, toda e qualquer responsabilidade não caberá ao administrador deste blog. Este blog não tem como objetivo reproduzir as obras, apenas divulgar o que foi encontrado na Internet. Os filmes aqui informados são de cunho científico assim como as séries, as quais são produzidas para exibição em TV aberta. Uma vez que a série não tenha sido ripada de um DVD, ou seja, a mesma foi gravada do sinal de TV aberta com o respectivo selo da emissora. Não é caracterizado crime, pois a mesma foi produzida para exibição pública. Será crime quando for realizado venda desta série ou filme. Quem efetuar download de qualquer ficheiro deste blog, que não tenha seu conteúdo de base Open Source (Código Aberto), ou FOSS (Free Open Source Software), deverá estar ciente que terá 24 horas para eliminar os ficheiros que baixou. Após assistir e gostar do filme ou série, adquira o original via lojas especializadas. Se algo contido no blog lhe causa dano ou prejuízo, entre em contato que iremos retirar o ficheiro ou post o mais rápido possível. Se encontrou algum post que considere de sua autoria, favor enviar e-mail para suporte@delphini.com.br informando o post e comprovando sua veracidade. Muito obrigado a todos que fizeram deste blog um sucesso.

Creative CommonsEsta obra está licenciada sob uma Licença Creative Commons. Você pode copiar, distribuir, exibir, executar, desde que seja dado crédito ao autor original (Citando nome do autor, data, local e link de onde tirou o texto). Você não pode fazer uso comercial desta obra.Você não pode criar obras derivadas.

Google+ Followers

Nossos 10 Posts Mais Populares