[前言:很多基本的语法之类的在笔记中没有提及,需要在看之前了解一下lua基本语法]
-- ======lua简单知识======
print(.02 + .01)-->0.03
print(2 + "3")-->5
print("2" + "6")-->8
print("2" .. "3")-->23
print("-2e2" * "6")-->-200*6
print(157 .. 428)-->157428
-- 数字不能和字符串+
-- 匿名函数
function test_func(func)
func()
end
test_func(
function()
print("s")
end
)
-- 可变参数(求平均值)
function average(...)
local s = 0
local arg = {...} -- 这个就代表着传入的多个参数
for k, v in pairs(arg) do
s = s + v
end
print(s / #arg)
return s / #arg
end
average(1, 1, 1, 2)
-- 逻辑运算符
print(true and false)
print(true or false)
print(not true)
-- 字符串
s = string.find("Hello Lua user", "Lua", 1) --最后的参数表示从第几个开始找
print(s)
-- string.format(字符串格式化)
s = string.format("字符串格式化 %s %s", "A", "B")
print(s)-->字符串 A B
date = 2; month = 1; year = 2014
print(string.format("日期格式化 %02d/%02d/%03d", date, month, year))
-- 十进制格式化
print(string.format("%.4f", 1 / 3)) -->精确到小数点后四位
-- 案例
tab = {
string.format("%c", 83), --输出S
string.format("%+d", 17.0), --输出 + 17
string.format("%.5d", 17), --输出00017
string.format("%o", 17), --输出21
string.format("%u", 3.14), --输出3
string.format("%x", 13), --输出d
string.format("%X", 13), --输出D
string.format("%e", 1000), --输出1.000000e + 03
string.format("%E", 1000), --输出1.000000E + 03
string.format("%.3f", 13), --输出13.000
string.format("%q", "One\nTwo"), --输出"One\Two"
string.format("%s", "monkey"), --输出monkey
string.format("%20s", "monkey"), --输出 monkey
string.format("%.4s", "monkey") --输出 mon
}
for k, v in pairs(tab) do
print(k, v)
end
-- 数字转换文字
local function NumToCN(num)
local size = #tostring(num)
local CN = ""
local StrCN = {"一", "二", "三", "四", "五", "六", "七", "八", "九"}
for i = 1, size do
CN = CN .. StrCN[tonumber(string.sub(tostring(num), i, i))]
end
return CN
end
print(NumToCN(56665))
-- 模拟字符串分割
function StrSplit(inputstr, sep)
if sep == nil then
sep = "%s"
end
local t = {}
local i = 1
for str in string.gmatch(inputstr, "([^"..sep.."]+)") do
t[i] = str
i = i + 1
end
return t
end
local a = "23245023496830,汉字。。。。"
local b = StrSplit(a, ",")
print(b[1])
-- 数组 索引是默认从1开始,但是可以自定义为从别的数字开始
array = {}
for i = -2, 2 do
array[i] = i * 2
end
for k, v in pairs(array) do
print(k, v)
end
-- ======lua难点======
-- 迭代器
-- [1].无状态的迭代器
-- 以下实例我们使用了一个简单的函数来实现迭代器,实现 数字 n 的平方:
function square(iteratorMaxCount, currentNumber) --iteratorMaxCount(状态常量),currentNumber(控制变量)
if currentNumber < iteratorMaxCount
then
currentNumber = currentNumber + 1
return currentNumber, currentNumber * currentNumber
end
end
for k, v in square, 3, 0
do
print(k, v)
end
-- ========实现简单的ipairs========
-- tip:迭代的状态包括被遍历的表(循环过程中不会改变的状态常量)和当前的索引下标(控制变量),
-- ipairs和迭代函数都很简单,我们在Lua中可以这样实现:
-- 在迭代数组的时候,如果遇到nil则会停止迭代
local tab = {1, 2, nil, 4, 5}
function iter (a, i)
i = i + 1
local v = a[i]
if v then
return i, v
end
end
function myipairs (a)
return iter, a, 0
end
for i, v in myipairs(tab) do
print(i, v)
end
print("-----对比------")
for i, v in ipairs(tab) do
print(i, v)
end
-- [2].多状态的迭代器(无法迭代有key的table)
array = {"Lua", "Tutorial", 2, [4] = 22, key1 = "ss", key2 = "nn"}
function elementIterator (collection)
local index = 0
local count = #collection
-- 闭包函数
return function ()
index = index + 1
if index <= count
then
-- 返回迭代器的当前元素
return collection[index]
end
end
end
for element in elementIterator(array)
do
print(element)
end
-- ========ipairs和pairs的异同(重要)========
-- 栗子1:
local tabFiles = {
[1] = "test2",
[6] = "test3",
[4] = "test1"
}
for k, v in ipairs(tabFiles) do --输出"test2",在key等于2处断开
print(k, v)
end
print("------------")
-- 栗子2:
local tabFiles = {
[2] = "test2",
[6] = "test3",
[4] = "test1"
}
-- 什么都没输出,为什么?因为控制变量初始值是按升序来遍历的,
-- 当key为1时,value为nil,此时便停止了遍历, 所有什么结果都没输出
for k, v in ipairs(tabFiles) do
print(k, v)
end
print("------------")
-- 栗子3:
local tabFiles = {
[2] = "test2",
[6] = "test3",
[4] = "test1"
}
for k, v in pairs(tabFiles) do --输出2 test2, 6 test3, 4 test1
print(k, v)
end
print("------------")
-- 栗子4:
-- 输出前三个 备注:因为第四个key不是整数
local tabFiles = {"alpha", "beta", [3] = "no", ["two"] = "yes"}
for i, v in ipairs(tabFiles) do
print(tabFiles [i])
end
print("------------")
for i, v in pairs(tabFiles) do --全部输出
print(tabFiles [i])
end
-- ======table的操作======
--[1] table.concat (连接)
tab1 = {1, 2, 3, 4, 5}
local concat_str_1arg = table.concat(tab1)
print(concat_str_1arg)
local concat_str_2arg = table.concat(tab1, ",")
print(concat_str_2arg)
local concat_str_3arg = table.concat(tab1, ",", 2)
print(concat_str_3arg)
local concat_str_4arg = table.concat(tab1, ",", 2, 4)
print(concat_str_4arg)
--[2] table.insert (插入)
tab1 = {"a", "b", "c", "d"}
table.insert(tab1, "e")
print(table.concat(tab1))
table.insert(tab1, 2, "1")
print(table.concat(tab1))
--[3] table.sort (排序,对数字和字母或者ASC码的都可以排序)
-- 默认从小到大排序
tab1 = {9, 5, 4, 3, 7, 11, 2, 6, 2}
table.sort(tab1)
print(table.concat(tab1, "<"))
-- 自定义从大到小排序
local function testSort(a, b)
return a > b
end
table.sort(tab1, testSort)
print(table.concat(tab1, ">"))
-- 字符串排序
tab2 = {"a", "b", "c"}
table.sort(tab2)
print(table.concat(tab2, "<"))
-- 注意以及技巧:
-- 当我们获取 table 的长度的时候无论是使用 # 还是 table.getn 其都会在索引中断的地方停止计数,而导致无法正确取得 table 的长度。
-- 可以使用以下方法来代替:
function table_leng(t)
local leng = 0
for k, v in pairs(t) do
leng = leng + 1
end
return leng;
end
tab = {1, key = 2, 3, 4}
for k, v in pairs(tab) do
print(k, v)
end
print(table.getn(tab))
print(#tab)
print(table_leng(tab))
-- ======lua元表(超级重点)======
--元表的两个函数 setmetatable getmetatable 下面是一个最简单的例子
mytable = {} -- 普通表
mymetatable = {} -- 元表
setmetatable(mytable,mymetatable) -- 把 mymetatable 设为 mytable 的元表
--可以简化成
mytable = setmetatable({}, {})
-- 元方法
-- [1] __index元方法
-- 当你通过键来访问 table 的时候,如果这个键没有值,那么Lua就会寻找该table的metatable(假定有metatable)中的__index 键。
-- 如果__index包含一个表格,Lua会在表格中查找相应的键。
-- 案例1
mytable = setmetatable({key = 1}, {__index = function (arg, key) --第一个参数为默认参数
if(key == "key2") then
return "metatablevalue"
end
end
})
print(mytable.key, mytable.key2)
案例2
mytable = setmetatable({key1 = 1}, {__index = {key2 = 2}})
print(mytable.key1, mytable.key2)
-- [2] __newindex元方法
-- __newindex 元方法用来对表更新,__index则用来对表访问 。
-- 当你给表的一个缺少的索引赋值,解释器就会查找__newindex 元方法:如果存在则调用这个函数而对普通表不进行赋值操作。
-- 如果存在__newindex元方法并且普通表中已经含有该键, 则会优先对普通表进行赋值
-- 以下实例演示了 __newindex 元方法的应用:
metatable = {key2 = 1}
mytable = setmetatable({mytablekey = 22}, {__newindex = metatable})
mytable.key2 = 2
print(mytable.key2, metatable.key2)
-- [3] __add元方法(表相加)
mytable = setmetatable({1, 2, 3}, {__add = function (mytable, newtable)
for i = 1, #newtable do
table.insert(mytable, #mytable + 1, newtable[i])
end
return mytable
end
})
newtable = {4, 4, 4}
mytable = mytable + newtable
for k, v in pairs(mytable) do
print(k, v)
end
-- 或者这样写
local mt = {}
mt.__add = function(a, b)
return a.v + b.v
end
local a = {v = 10}
local b = {v = 12}
setmetatable(a, mt)
print("a + b :", a + b)
-- [4.1] __metatable元方法保护元表不被查看和修改
mytable = setmetatable({1, 2, 3}, {__metatable = "you can not get the metatable"})
print(getmetatable(mytable))
或者这样写
local mt = {}
mt.__metatable = "you can not get the metatable"
mytable = {}
setmetatable(mytable, mt)
print(getmetatable(mytable))
-- [4.2]写一个只读的表,只需跟踪所有对table的更新操作,并引发一个错误即可
function readOnly(table)
local proxy = {}
local mt = {
__index = table,
__newindex = function(table, k, v)
error("attempt to update a read-only table")
end
}
setmetatable(proxy, mt)
return proxy
end
days = readOnly({"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"})
print(days[1])
days[2] = "Noday"
-- [5] 其余的操作符元方法
-- __add对应的运算符 '+'
-- __sub对应的运算符 '-'
-- __mul对应的运算符 '*'
-- __div对应的运算符 '/'
-- __mod对应的运算符 '%'
-- __unm对应的运算符 '-'
-- __concat对应的运算符 '..'
-- __eq对应的运算符 '=='
-- __lt对应的运算符 '<'
-- __le对应的运算符 '<='
-- [6] __call元方法
-- 当调用一个不是函数的值的时候会去查找call这个元方法,例如使用table作为方法(table())来调用的时候,call元方法则会被调用,
-- func指代的是table本身的地址
local mt = {}
mt.__call = function(func, ...)
print("call table like a function", func, ...)
end
local temp = {}
setmetatable(temp, mt)
temp(1, 2, 3)
-- [7] __tostring 元方法
-- __tostring 元方法用于修改表的输出行为,类似c#重写toString
mytable = setmetatable({10, 20, 30}, {
__tostring = function(mytable)
sum = 0
for k, v in pairs(mytable) do
sum = sum + v
end
return "表所有元素的和为:" .. sum
end
})
print(mytable)
-- ======lua协同程序======
-- coroutine.create()
-- 创建coroutine,返回coroutine, 参数是一个函数,当和resume配合使用的时候就唤醒函数调用
-- coroutine.resume()
-- 重启coroutine,和create配合使用
-- coroutine.yield()
-- 挂起coroutine,将coroutine设置为挂起状态,这个和resume配合使用能有很多有用的效果
-- coroutine.status()
-- 查看coroutine的状态
-- 注:coroutine的状态有三种:dead,suspend,running,具体什么时候有这样的状态请参考下面的程序
-- coroutine.wrap()
-- 创建coroutine,返回一个函数,一旦你调用这个函数,就进入coroutine,和create功能重复
-- coroutine.running()
-- 返回正在跑的coroutine,一个coroutine就是一个线程,当使用running的时候,就是返回一个corouting的线程号
-- 使用下面的程序来了解一下这几个函数的基本用法:
co = coroutine.create(
function(i)
print(i);
end
)
coroutine.resume(co, 1) -- 1
print(coroutine.status(co)) -- dead
print("----------")
co = coroutine.wrap(
function(i)
print(i);
end
)
co(1) --1
print("----------"
co2 = coroutine.create(
function()
for i = 1, 10 do
print(i)
if i == 3 then
print(coroutine.status(co2)) --running
print(coroutine.running()) --thread:XXXXXX
end
coroutine.yield()
end
end
)
coroutine.resume(co2) --1
coroutine.resume(co2) --2
coroutine.resume(co2) --3
print(coroutine.status(co2)) -- suspended
print(coroutine.running()) --nil
print("----------")
-- ======lua文件IO======
####### -- [[ 在此省略,与其他语言的文件操作类似
-- ======lua垃圾回收机制======
-- 检测lua内存泄漏的案例:
collectgarbage("collect") --垃圾收集(释放内存)
local s1 = collectgarbage("count") -- 垃圾统计(占用了多少内存(kb))
print(">>>>>>>>>>>>>>>> count1", s1)
local my_list = {}
for i = 1, 1000, 1 do
local v = {}
v[1], v[2] = 1024 + i, 32 + i
my_list[v[1]] = v[2]
end
print(">>>>>>>>>>>>>>>> count2", collectgarbage("count")) -- 局部变量(v)和my_list所占用的内存
collectgarbage("collect")
print(">>>>>>>>>>>>>>>> count3", collectgarbage("count")) -- 注:使用“collectgarbage("collect")”,
局部变量v被回收,my_list没有被回收
如果这里不置为空,则出现内存泄漏了
my_list = nil
collectgarbage("collect")
print(">>>>>>>>>>>>>>>> count4", collectgarbage("count")) -- 销毁my_list之后被回收
-- 总结一: 如何监测Lua的编程产生内存泄露:
-- 1. 针对会产生泄露的函数,先调用collectgarbage("count"),取得最初的内存使用
-- 2. 函数调用后, collectgarbage("collect")进行收集, 并使用collectgarbage("count")再取得当前内存, 最后记录两次的使用差
-- 3. 从test1的收集可看到, collectgarbage("collect")被调用,并不保证一次成功, 所以, 大可以调用多次
-- 总结二: 如何避免Lua应用中出现的内存使用过大行为:
-- 1. 当然是代码实现不出现泄露
-- 2. 在测试中,其实还发现, Lua中被分配的内存,其实并不会自动回收(个人估计要么就是Lua虚拟机没有做这个事情,
-- 要么就是回收的时机是在C层), 所以, 为了避免内存过大, 应用的运行时,可能需要定期的(调用collectgarbage("collect"),
-- 又或者collectgarbage("step"))进行显式回收。
-- ======lua模拟面向对象======
-- Q:如何定义对象的方法以及调用对象的方法?
-- A:面向对象的特殊性在于它以this指针的方式传递了对象本身,并且这种操作是隐藏起来的。
-- 在Lua中使用:实现面向对象方式的调用。:只是一个语法糖,它同时在方法的声明与实现中增加一个名为self的隐藏参数(对象本身)。
Account = {balance = 1000} -- 账户余额初始为1000。
--[[ 取钱。
使用面向对象的方式隐藏了"self"参数,
"withdraw()"完整的参数列表是"Account.withdraw(self, v)"。]]
function Account:withdraw(v)
self.balance = self.balance - v
end
--[[ 使用面向对象的方式隐藏了"self"参数,
实际传递给"withdraw()"的参数是"Account"和"100.00"。]]
Account:withdraw(100.00)
print(Account.balance) --> 900.0
我们可以用.定义函数,而用:调用函数,或者反之亦然,只要我们正确的使用这个被隐藏的self参数。
Account = {balance = 1000} -- 账户余额初始为1000。
function Account.withdraw(self, v) -- 使用"."定义函数。
self.balance = self.balance - v
end
Account:withdraw(100.00) -- 使用":"调用函数。
print(Account.balance) --> 900.0
-- 存钱。
function Account:deposit(v) -- 使用":"定义函数。
self.balance = self.balance + v
end
Account.deposit(Account, 600.00) -- 使用"."调用函数。
print(Account.balance) --> 1500.0
-- Q:如何实现类?
-- A:类在面向对象语言中就好象一个模板,通过模板所创建的实例就具有模板中规定的特性。Lua中没有类的概念,
-- 每一个对象规定自己的行为,每一个对象就是自己的实例。不过在Lua中模拟“类”并不难,我们可以用继承的概念,使用两个对象,
-- 让其中一个对象作为另一个对象的“类”,
-- setmetatable(a, {__index = b}) -- b作为a的类,在a中找不到的方法都将去b中寻找。
-- 继续扩展银行账户的例子
Account = {balance = 100} -- 账户余额初始为0。
function Account:new (o)
o = o or {} -- create object if user does not provide one
setmetatable(o, self) -- 新对象的"metatable"是"Account"(或其子类)。
self.__index = self -- 新对象"metatable"中的"__index"依旧是"Account"(或其子类)。
return o
end
function Account:deposit(v)
self.balance = self.balance + v
end
function Account:withdraw(v)
self.balance = self.balance - v
end
--[[ "account1"继承了"Account"中的特性,
就好象"account1"是由"Account类"创建出来的一样。
这一句代码后,设置了"account1"的"metatable"是"Account",
"Account.__index"依旧是"Account"。]]
account1 = Account:new()
-- 这里打印的是"Account.balance","Account.balance"作为"Account"实例的默认值。
print(account1.balance) --> 100
print(Account.balance) --> 100
--[[ "account1:deposit(500.00)",实际上调用的是"account1.deposit(a, 500.00)",
"account1"中没有"deposit()",所以去找"account1"的"metatable"中的"__index",
即"getmetatable(account1).__index",即"Account"。
又因为"Account"是一个"table",所以"account1.deposit(a, 500.00)"
相当于"Account.deposit(a, 500.00)"。]]
account1:deposit(500.00)
--[[ 这里打印的是"account1.balance",
因为在"Account.deposit()"中为"self.balance"赋值的同时定义了"account1.balance"。]]
print(account1.balance) --> 600
print(Account.balance) --> 100
-- Q:如何实现继承?
-- A:上面的例子中已经初步展现了继承的方式,下面再使用一个更贴切的例子进行说明,
Account = {balance = 0}
function Account:new (o)
o = o or {}
setmetatable(o, self)
self.__index = self
return o
end
function Account:deposit (v)
self.balance = self.balance + v
end
function Account:withdraw (v)
-- 普通账户不可以透支。
if v > self.balance then error"insufficient funds" end
self.balance = self.balance - v
end
--[[ 信用卡账户继承自普通账户,可以透支。
"CreditAccount"是"Account"的一个“实例”,
但他同时也可以作为一个“类”以产生其他实例。]]
CreditAccount = Account:new{limit = 1000.00}
-- 为了让信用卡账户能够透支,需要重写"withdraw()"方法。
function CreditAccount:withdraw (v)
-- 信用卡账户在一定额度内可以透支。
if v - self.balance >= self:getLimit() then
error"insufficient funds"
end
self.balance = self.balance - v
end
function CreditAccount:getLimit ()
return self.limit or 0
end
--[[ 新的实例也可以规定自己的限额。
"CreditAccount"中没有"new()",实际调用的是"Account.new()"。]]
creditaccount1 = CreditAccount:new{limit = 2000.00}
--[[ "creditaccount1"中没有"deposit()",
"CreditAccount"中没有"deposit()",实际调用的是"Account.deposit()"。]]
creditaccount1:deposit(100.00)
-- 此时调用的是"CreditAccount:withdraw()"。
creditaccount1:withdraw(200.00)
print(creditaccount1.balance) --> -100.0
-- Q:如何实现多重继承?
-- A:将__index赋值为一个函数,函数中可以搜索想要找的表(“父类”)。
-- 还记得吗,当__index是个函数时,Lua调用它,以”table”和缺失的”key”作为参数。而当__index是一个”table”时,
-- Lua直接以缺失的”key”作为它的”key”再次访问他(相当于拿着缺失的”key”在它这张”table”中寻找)。
-- ------------------- "Account类" -------------------
Account = {balance = 0}
function Account:new (o)
o = o or {}
setmetatable(o, self)
self.__index = self
return o
end
function Account:deposit (v)
self.balance = self.balance + v
end
function Account:withdraw (v)
if v > self.balance then error"insufficient funds" end
self.balance = self.balance - v
end
--------------------------------------------------
-- look up for 'k' in list of tables 'plist'
local function search(k, plist)
for i = 1, #plist do
local v = plist[i][k] -- try 'i'-th superclass
if v then return v end
end
end
function createClass(...)
local c = {} -- new class
for i = 1, select('#', ...) do
-- arg = {[1] = Account, [2] = Named}。
arg[i] = select(i, ...)
end
--[[ class will search for each method in the list of its
parents ('arg' is the list of parents)]]
setmetatable(c, {__index = function (t, k)
return search(k, arg)
end})
-- prepare 'c' to be the metatable of its instances
c.__index = c
-- define a new constructor for this new class
function c:new (o)
o = o or {}
setmetatable(o, c)
return o
end
-- return new class
return c
end
Named = {} -- 姓名类,记录账户的姓名。
function Named:getname ()
return self.name
end
function Named:setname (n)
self.name = n
end
-- 创建一个新类"NamedAccount",其继承于"Account"与"Named"。
NamedAccount = createClass(Account, Named)
account = NamedAccount:new{name = "Paul"}
--[[ "account"中没有"getname",
所以找"account"的"metatable.__index",
"metatable"是"NamedAccount",
"NamedAccount"的"__index"还是"NamedAccount"。
而"NamedAccount"中依旧没有"getname()",
所以找"NamedAccount"的"metatable.__index",是个函数,
所以Lua调用这个函数,并将"NamedAccount"和"getname"作为参数传入。
函数中又调用"search()","search()"中首先在"Account"中找"getname",
没找到,又在"Named"中找"getname",找到了,所以调用"getname()"。]]
print(account:getname()) --> Paul
多重继承的效率可能比单一继承的效率低很多(因为多了search()这个过程)。如果想提高效率的话可以将找到的父类的函数拷贝到子类中,
setmetatable(c, {__index = function (t, k)
local v = search(k, arg)
t[k] = v -- "Named.getname()"存储在了"account"中。
return v
end})
-- 这样,除了第一次调用,之后的调用实际上是调用子类中拷贝过来的父类的函数,省去了search()的过程,
-- 效率就高很多。但是这种做法也有缺陷,在程序运行起来之后,就很难改变父类中的方法了,因为即使更改了,
-- 子类也不会继承过去(子类保存了父类原先的方法)。
-- Q:如何定义私有成员或私有方法?
-- A:使用两个”table”,其一存储私有成员,另一个存储公有成员和公有方法,两个”table”组成”Closure”,
-- 私有”table”作为公有”table”的”Closure”被访问,私有方法直接存储在”Closure”中,
function newAccount (initialBalance)
-- 私有"table"。
local self = {
balance = initialBalance, -- 余额。
count = 0 -- 积分。
}
-- 私有方法,未导出到公有"table"中,外部无法访问。
local addCount = function (v)
self.count = self.count + v * 0.1 -- 消费的10%作为积分。
end
local withdraw = function (v)
self.balance = self.balance - v
addCount(v)
end
local deposit = function (v)
self.balance = self.balance + v
end
local getBalance = function () return self.balance end
local getCount = function () return self.count end
-- 公有"table"。
return {
withdraw = withdraw,
deposit = deposit,
getBalance = getBalance,
getCount = getCount
}
end
account = newAccount(100)
print(account.balance) --> nil
print(account.count) --> nil
print(account.getBalance(), account.getCount()) --> 100 0
account.deposit(500)
print(account.getBalance(), account.getCount()) --> 600 0
account.withdraw(100)
print(account.getBalance(), account.getCount()) --> 500 10
-- 附加:
-- 1、Lua中的”table”与面向对象编程中的对象有很多相似的地方。像对象一样,”table”有成员变量;
-- 像对象一样,”table”本身与其存储的值相互独立,特别在于两个不同的对象拥有相同的值,但他们依旧是不同的对象。
-- 反之,一个对象在不同的时间可以有不同的值,但对象本身不会改变;像对象一样,”table”的生命周期与其被谁创建以及在哪儿被创建无关。
-- 2、Lua中的面向对象编程有意思的地方在于,当你需要增加新的方法时,既可以在“类”中添加,也可以在“实例”中直接添加。
-- -- 以添加一个“增加积分”的方法为例。
-- -- 在“类”中添加,适用于许多用户均需要该方法。
-- function CreditAccount:addCount(count) ... end
-- -- 在“实例”中直接添加,适用于少数用户需要该方法。
-- creditaccount1 = CreditAccount:new()
-- creditaccount1.addCount = function(self, count) ... end
-- 3、Lua使用”table”表示对象,本身不提供私有性机制。Lua的设计初衷是针对于中小型程序,
-- 通常他们是一个大型系统的一部分。因此Lua避免设计上的冗余以及过多的人为限制,如果对象中的某些成员你不该访问,
-- 那么你最好就”just do not do it”。Lua提供给程序员“meta-mechanisms”,程序员可以通过他们模拟许多需要的特性。
-- ======结束======
网友评论