Difference between revisions of "Lua"
(→Inheritance) |
(→Conditional) |
||
Line 118: | Line 118: | ||
| or || Called Logical OR Operator. If any of the two operands is non zero then condition becomes true. || (A or B) is true. | | or || Called Logical OR Operator. If any of the two operands is non zero then condition becomes true. || (A or B) is true. | ||
|- | |- | ||
− | | not || Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false. || | + | | not || Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false. || not(A and B) is true. |
|} | |} | ||
Latest revision as of 10:26, 4 July 2019
Contents
Comments
Lua implements comments by:
-- Two dashes start a one-line comment.
--[[
Adding two ['s and ]'s makes it a
multi-line comment.
--]]
Write to Console
Lua provides 2 ways to write to the console:
print("helloworld")
io.write('helloworld')
Escape Characters
These can also include escape characters in the string, eg '\n':
io.write('helloworld\n')
Read from Console
Lua can read from the keyboard (ie Console.ReadLine() in C# or input() in Python), you can also convert this input to a number:
input = io.read()
-- Convert input to a number
num = tonumber(io.read())
Variables
Lua uses variables similar to python, you don't need to specify a data type:
Numbers
num = 42 -- All numbers are doubles.
Strings
s = 'walternate' -- Immutable strings like Python.
t = "double-quotes are also fine"
u = [[ Double brackets
start and end
multi-line strings.]]
-- String concatenation uses the .. operator:
message = 'Winter is coming, ' .. line
Empty / Null
t = nil -- Undefines t; Lua has garbage collection.
Global Variables
The default in Lua is that all variables are global (in python all variables are local):
-- Variables are global by default.
thisIsGlobal = 5 -- Camel case is common.
Local Variables
To specify a variable is only local, you need to include 'local' before the variable name:
-- How to make a variable local:
local line = io.read() -- Reads next stdin line.
If Statement
Lua implements IF statements, but doesn't implement a Switch Case statement. An example if is shown below:
if num < 40 then
print('below 40')
elseif name ~= 'wayne' then
-- ~= is not equals.
-- Equality check is == like Python; ok for strs.
io.write('over 40 and Name is wayne\n') -- Defaults to stdout.
else
print('above 40')
end
Operators
Within if statements and also within loops, the following relational and conditional operates exist:
Relational
Symbols | Explanation |
---|---|
== | Equal |
~= | Not equal |
<= | Less than or equal |
>= | Greater than or equal |
< | Less than |
> | Greater than |
Conditional
Operator | Description | Example |
---|---|---|
and | Called Logical AND operator. If both the operands are non zero then condition becomes true. | (A and B) is false |
or | Called Logical OR Operator. If any of the two operands is non zero then condition becomes true. | (A or B) is true. |
not | Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false. | not(A and B) is true. |
Loops
Just like other languages Lua has the standard 3 types of loop. While will run 0 or more times (may never run), Repeat will run at least once, For will run an exact number of times:
While
-- Blocks are denoted with keywords like do/end:
while num < 50 do
num = num + 1 -- No ++ or += type operators.
end
For
karlSum = 0
for i = 1, 100 do -- The range includes both ends.
karlSum = karlSum + i
end
-- Use "100, 1, -1" as the range to count down:
fredSum = 0
for j = 100, 1, -1 do
fredSum = fredSum + j
end
-- In general, the range is begin, end[, step].
Repeat / Do While
-- Another loop construct:
repeat
print('the way of the future')
num = num - 1
until num == 0
Functions
Declaring a function
You can declare a function using the command 'function', the parameters will be within the round brackets '()'. The use of 'local' is not really required:
local function add(first_number, second_number)
print(first_number + second_number)
end
add(2, 3) -- calling a method
Returning a value
You can return a value from a function by using 'return'
local function add(first_number, second_number)
return first_number + second_number
end
print(add(5, 6))
Classes - Table Based
Just like other programming languages, Lua is can be used in an OOP way. Lua calls '{}' tables or meta tables, but they are the same as a class really:
Define a class
-- Meta class, class defined with {}, variables can be set like 'area'
Shape = {area = 0}
-- Base class is named, followed by ':' to create a method for the class
function Shape:new (o,side)
o = o or {} -- if an object is passed, use it or create an empty one
setmetatable(o, self)
self.__index = self
side = side or 0 -- if side is passed, use it or set side to 0
self.area = side*side;
return o
end
-- Base class method printArea
function Shape:printArea ()
print("The area is ",self.area)
end
Creating an object
-- Creating an object
myshape = Shape:new(nil,10)
--to access the methods of the object you need to use ':'
myshape:printArea()
Inheritance
Square = Shape:new()
-- Derived class method new
function Square:new (o,side)
o = o or Shape:new(o,side) -- if an object is passed, use it or create a new shape
setmetatable(o, self)
self.__index = self
return o
end
You can override an inherited method by redeclaring it:
-- Derived class method printArea
function Square:printArea ()
print("The area of square is ",self.area)
end
Classes - Closure Based
Lua can implement classes in a second way:
Define a Class
function MyClass(init)
-- the new instance
local self = {
-- public fields go in the instance table
public_field = 0
}
-- private fields are implemented using locals
-- they are faster than table access, and are truly private, so the code that uses your class can't get them
local private_field = init
function self.foo()
return self.public_field + private_field
end
function self.bar()
private_field = private_field + 1
end
-- return the instance
return self
end
Creating an Object
Creating and using an instance can be done with:
local i = MyClass(5)
print(i.foo()) --> 5
i.public_field = 3
i.bar()
Inheritance
This is the base class, and below a subclass derived from it:
function BaseClass(init)
local self = {}
local private_field = init
function self.foo()
return private_field
end
function self.bar()
private_field = private_field + 1
end
-- return the instance
return self
end
function DerivedClass(init, init2)
local self = BaseClass(init)
-- Public fields can be added to the derived version
self.public_field = init2
-- this is independent from the base class's private field that has the same name
-- the derived value would be self.private_field
local private_field = init2
-- save the base version of foo for use in the derived version
local base_foo = self.foo
-- this function overrides the derived version
function self.foo()
return private_field + self.public_field + base_foo()
end
-- return the instance
return self
end