Introduction to Lua

Introduction to Lua
Trevor Brown

View Slide

Trevor Brown
Sarasota, Fl
JavaScript, Erlang, Elixir, Ruby
Software Developer at Voalte
@Stratus3D
Github.com/Stratus3D
[email protected]

View Slide

Lua

View Slide

What is Lua?

View Slide

Lua
• Interpreted scripting language
• Dynamically typed
• Automatic memory management
• Multi-paradigm – procedural,
classical OO, prototypal OO, and functional
• Created in 1993 by Roberto Ierusalimschy
• Open source – release under the MIT license
• Extremely small (source code and
documentation archive is under 1 MB)
Lua

View Slide

Lua's Strengths
• Simple
– Lua has relatively few programming
constructs
• Efficient
– Lua is one of the fasted interpreted languages today.
LuaJIT makes it even faster
http://luajit.org/
• Portable
– Lua is written in ANSI C
• Extensible
– Lua can be easily extended with C code
– Can also easily interface with many other languages
Lua

View Slide

Where should Lua be
used?
• Education
– Lua's simplicity makes it a good first language
– Similar to JavaScript
• Places low latency scripting is required
– Lua's efficiency and simplicity make an ideal choice
• Places application portability is required
– Any architecture that can execute C code can run Lua
• Embedded Scripting
– Easy to embed in existing enterprise applications

View Slide

Where is Lua Used?
• Redis
• Wireshark
• Freeswitch
• Both Nginx and Apache have Lua modules
• NeoVim
• MineCraft (and many other games)

View Slide

Who Uses Lua?
• GitHub – GitHub Pages routing
http://githubengineering.com/rearchitecting-github-pages/
• Cloudflare – Firewall and HTTP request
preprocessor
http://openresty.org/
• Adobe – Photoshop Lightroom
https://www.adobe.com/devnet/photoshoplightroom.html
• Lego Mindstorms NXT – scripting
http://shop.lego.com/en-US/Mindstorms-EV3

View Slide

Lua Basics

View Slide

Comments and Strings
comments start with two dashes
[[
adding two square brackets
makes the comments multiline
]]
string = 'single quoted strings'
another_sting = "are the same as double quoted"
multiline = [[
foo
bar
]]
strings can be concatenated with `..`
both = 'one' .. ' two three'
print(both) > 'one two three'

View Slide

Numbers
all numbers are double precision floating
point values (IEEE 754 floats)
Num = 42
arithmetic expressions that can return integer
values will
num3 = num / 7 > 6.0
equal = (6 == num3) > true (6 == 6.0)
some can't and will return floats
num2 = num / 9 > 4.6666666666667
num4 = num + 0.5 > 42.5
http://luausers.org/wiki/NumbersTutorial

View Slide

Booleans
booleanValue = true
`not` can be used to invert boolean values
oppositeValue = not booleanValue > false
definitelyBoolean = not not booleanValue > true
if not oppositeValue then print('it was false')
end
> it was false
`not` coerces other types to booleans
all values except nil and false are truthy
print(not 'a') > false
print(not not 'a') > true

View Slide

Tables
empty = {}
tables are key value stores
user = {name = 'Roberto', favorite_language = 'Lua'}
similar to JavaScript objects, only no methods exist on
the table
user2 = {name = 'Joe', favorite_language = 'Erlang'}
but you can add your own functions to the table
user2.print_func = print
looking up the value of a string key is trivial
firstname = user2.name > 'Joe'
firstname = user2['name'] > 'Joe'

View Slide

Tables (cont.)
both keys and values can of any type, but by
default keys are strings
numbers = {[12] = 'twelve', [13] = 'thirteen',
[14] = 'fourteen'}
tables can represent arrays
array = {'a', 'b', 'c'}
this is really a table. it is stored as this:
{1 = 'a', 2 = 'b', 3 = 'c'}
getting the length of array is easy
length = #array > 3

View Slide

Tables (cont.)
iterating over tables is trivial
print_table = function (table)
for k, v in pairs(table) do
print('key:', k, 'value:', v)
end
End
print_table(user)
> key: name value: Roberto
> key: favorite_language value: Lua
print_table(array)
> key: 1 value: a
> key: 2 value: b
> key: 3 value: c

View Slide

Nil
when a key is missing in a table nil
is returned
table = {}
print(table.nonExistent) > nil
setting a variable to nil allows the
value of the variable to be garbage
collected
largeValue = nil
`largeValue` will now be removed from
memory

View Slide

Functions
function add (a, b)
return a + b
end
add(2,3) > 5
closures and anonymous functions are possible
function multiply_by(x)
return function (y) return y * x end
end
double = multiply_by(2) functions are first class
double(8) > 16

View Slide

Functions (cont.)
recursive functions are possible
function factorial(num, acc)
acc = acc or 1
if num == 0 then
return acc
else
return factorial(num 1, num * acc)
end
end
all parameters need not be present
factorial(6) in this case `acc` will default to nil
> 720

View Slide

Functions (cont.)
functions calls can return multiple values
function multiples_of(num)
return 1 * num, 2 * num, 3 * num
end
multiples_of(4) > 4 8 12
functions can take a variable number of arguments
function add_all(...)
local sum = 0
for index, value in ipairs{...} do
sum = sum + value
end
return sum
end
add_all(1,2,3,4) > 10

View Slide

Scope
global_scope = _G
variables in the global scope are really attributes on `_G`
print(global_scope == _G.global_scope) > true
variables can be local to the block they are declared in
if x > 1 then
local y = 10
print(y)
end
print_lang = function ()
local lang = 'Lua'
print(lang)
end

View Slide

Metatables and Objects

View Slide

Metatables
metatables can contain various attributes that
are read by Lua when performing certainly
operations.
defaults = {favorite_language = 'Lua'}
defaults.__index = defaults
user = {}
if we set `defaults` as the metatable lua will
check the table assigned to the metatables
`__index` attribute if a key is missing
setmetatable(user, defaults)
print(getmetatable(user)) > table: 0x15ebe60
print(user.favorite_language) > 'Lua'

View Slide

Metatables
defaults
defaults = {
favorite_language = 'Lua'
}
defaults.__index = defaults
user = {}
setmetatable(user, defaults)
print(user.favorite_language)
> 'Lua'
what happens on that last
line?
print(user.favoritie_language)
user
Lookup
favorite_language
Key missing
check metatable
defaults'
__index
is itself
Lookup favorite_language on
defaults and return the value

View Slide

Objects
local User = {}
User.__index = User
function User:new(first_name, last_name, favorite_language)
local user = {
first_name = first_name,
last_name = last_name,
favorite_language = favorite_language
}
setmetatable(user, User)
return user
end

View Slide

Objects
this:
function User:display_name()
return self.first_name .. ' ' .. self.last_name
end
is the same as this:
function User.display_name(self)
return self.first_name .. ' ' .. self.last_name
end
User.__tostring = User.display_name
local u = User:new('Joe', 'Armstrong', 'Erlang')
print(u:display_name()) > 'Joe Armstrong'
print(u) > 'Joe Armstrong'

View Slide

Demo

View Slide

Conclusion
●
Lua is great for small standalone
applications
●
Great for embedded applications or for
embedding inside existing applications
●
Great language for scripting in general
●
Great for education
●
Definitely some quirks that take getting
used to

View Slide

Quirks
●
No variable incrementing shortcut (e.g a += 1)
●
Not equal is `~=` (e.g. a ~= 2)
●
But `~(a == 2)` is invalid. It must be `not
(a == b)`
●
Ternary operator ugly
– Local square = is_square(box) and
“it's a square” or “not a square”
●
Table indices start at 1

View Slide

If you want to learn
more
Programming in Lua
by Roberto Ierusalimschy

View Slide

Trevor Brown
@Stratus3D
Github.com/Stratus3D
[email protected]
https://github.com/srqsoftware/08-26-2015_Introduction-To-Lua
https://github.com/Stratus3D/lua_tetris

View Slide

Introduction to Lua

Introduction to Lua

Trevor Brown

More Decks by Trevor Brown

Other Decks in Programming

Featured

Transcript