Lua:table与object开发者社区

link管理

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

Lua:table与object

List = {first = 0, last = -1}
function List:popleft ()
local first = self.first
if first > self.last then error("list is empty") end
local value = self[first]
 self[first] = nil -- to allow garbage collection
 self.first = first + 1
return value
function List:pushright(value)
local last = self.last + 1
 self.last = last
 self[last] = value
List:pushright(123)
print(List:popleft()) -->123

local strs = {};
for i = 1, 30000, 1 do
strs[i] = "helloworld"
local result = "";
local startTime = os.clock();
for index, str in ipairs(strs) do
    result = result .. str;
local endTime = os.clock();
local useTime = endTime - startTime;
print("消耗时间：" .. useTime .. "s");
result = "";
startTime = os.clock();
result = table.concat(strs);
endTime = os.clock();
useTime = endTime - startTime;
print("concat消耗时间：" .. useTime .. "s");
--消耗时间：0.726s
--concat消耗时间：0.001s

    local mt = {} --第一步：定义一个元表 
    local MyTable = {}
    function MyTable.new(value) --第二步：创建表的时候同时指定对应的 metatable，这样一来， MyTable.new 创建的所有的集合都有相同的 metatable 了
        local t = {}
        setmetatable(t, mt)
        for k,v in ipairs(value) do
            t[k] = v
        return t
    function MyTable.add(a, b)
        local t = {}
        for k,v in ipairs(a) do
            t[k] = a[k] + b[k]
        return t
 --第三步，给 metatable 增加__add 函数，指定函数的行为在子表中实现或者创建一个函数实现，相当于运算符重载
    mt.__add = MyTable.add --除此之外还有__sub(减法), __mul(乘法), __div(除法), __unm(相反数), __mod(取余), __pow(乘幂)等算术方法
    mt.__sub = function(a, b) --也可以这么写
        local t = {}
        for k,v in ipairs(a) do
            t[k] = a[k] - b[k]
        return t
    local test1 = MyTable.new({1, 2})
    local test2 = MyTable.new({3, 4})
    local testAdd = test1 + test2
    local testSub = test1 - test2
 --第三步，给 metatable 增加__add 函数，指定函数的行为在子表中实现或者创建一个函数实现，相当于运算符重载
    mt.__add = MyTable.add --除此之外还有__sub(减法), __mul(乘法), __div(除法), __unm(相反数), __mod(取余), __pow(乘幂)等算术方法
    mt.__sub = function(a, b) --也可以这么写
        local t = {}
        for k,v in ipairs(a) do
            t[k] = a[k] - b[k]
        return t
    local test1 = MyTable.new({1, 2})
    local test2 = MyTable.new({3, 4})
    local testAdd = test1 + test2
    local testSub = test1 - test2

local mt = {} --定义一个元表
    local MyTable = {}
    function MyTable.new(value)
        local t = {}
        setmetatable(t, mt)
        for k,v in ipairs(value) do
            t[k] = v
        return t
    function MyTable.add(a, b)
        local t = {}
        for k,v in ipairs(a) do
            t[k] = a[k] + b[k]
        return t
	--[[function MyTable.tostring(set)
		local s = "{"
		local sep = ""
		for e in pairs(set) do
		 s = s .. sep .. e
		 sep = ", "
		return s .. "}"
	function MyTable.tostring(set)
		local s = "{"
		s = table.concat(set,",")
		return"{" .. s .. "}"
    mt.__add = MyTable.add --除此之外还有__sub(减法), __mul(乘法), __div(除法), __unm(相反数), __mod(取余), __pow(乘幂)等算术方法
    mt.__sub = function(a, b) --也可以这么写
        local t = {}
        for k,v in ipairs(a) do
            t[k] = a[k] - b[k]
        return t
	mt.__tostring = MyTable.tostring
    local test1 = MyTable.new({1, 2})
    local test2 = MyTable.new({3, 4})
    local testAdd = test1 + test2
    local testSub = test1 - test2
print(test1)-->{1,2}

mytable = setmetatable({key1 = "value1"}, {
  __index = function(mytable, key)
    if key == "key2" then
      return "metatablevalue"
      return nil
print(mytable.key1,mytable.key2)--》value1    metatablevalue

mymetatable = {}
mytable = setmetatable({key1 = "value1"}, { __newindex = mymetatable })
print(mytable.key1)
mytable.newkey = "新值2"
print(mytable.newkey,mymetatable.newkey)
mytable.key1 = "新值1"
print(mytable.key1,mymetatable.key1)

local key = {} -- unique key
local mt = {__index = function (t) return t[key] end}
function setDefault (t, d)
 t[key] = d
 setmetatable(t, mt)
tab = {x=10, y=20}
print(tab.x, tab.z) --> 10 nil
setDefault(tab, 0)
print(tab.x, tab.q) --> 10 0

t = {} 
-- original table (created somewhere)  
-- keep a private access to original table  
local _t = t  
-- create proxy  
t = {}  
-- create metatable  
local mt = {  
 __index = function (t,k)  
 print("*access to element " .. tostring(k))  
return _t[k] -- access the original table  
 __newindex = function (t,k,v)  
 print("*update of element " .. tostring(k) ..  
" to " .. tostring(v))  
 _t[k] = v 
-- update original table  
setmetatable(t, mt) 
> t[2] = 'hello'  
*update of element 2 to hello  
> print(t[2])  
*access to element 2  
hello

function readOnly (t)
local proxy = {}
local mt = { -- create metatable
 __index = t,
 __newindex = function (t,k,v)
 error("attempt to update a read-only table", 2)
 setmetatable(proxy, mt)
return proxy
days = readOnly{"Sunday", "Monday", "Tuesday", "Wednesday",
 "Thursday", "Friday", "Saturday"}
print(days[1]) --> Sunday
days[2] = "Noday"

function setfield (f, v)
local t = _G -- start with the table of globals
for w, d in string.gfind(f, "([%w_]+)(.?)") do
 if d == "." then -- not last field?
 t[w] = t[w] or {} -- create table if absent
 t = t[w] -- get the table
 else -- last field
 t[w] = v -- do the assignment
function getfield (f)
local v = _G -- start with the table of globals
for w in string.gfind(f, "[%w_]+") do
 v = v[w]
return v
setfield("t.x.y", 10)
print(t.x.y) --> 10
print(getfield("t.x.y")) --> 10

local declaredNames = {}
function declare (name, initval)
 rawset(_G, name, initval)
 declaredNames[name] = true
setmetatable(_G, {
 __newindex = function (t, n, v)
if not declaredNames[n] then
 error("attempt to write to undeclared var. "..n, 2)
 rawset(t, n, v) -- do the actual set
 __index = function (_, n)
if not declaredNames[n] then
 error("attempt to read undeclared var. "..n, 2)
 return nil
declare ("a",1)
print(a)

complex = {}  
function complex.new (r, i) return {r=r, i=i} end 
-- defines a constant `i'  
complex.i = complex.new(0, 1)  
function complex.add (c1, c2)  
return complex.new(c1.r + c2.r, c1.i + c2.i)  
function complex.sub (c1, c2)  
return complex.new(c1.r - c2.r, c1.i - c2.i)  
return complex

local P = {}  
complex = P  
local function checkComplex (c)  
if not ((type(c) == "table") and 
 tonumber(c.r) and tonumber(c.i)) then 
 error("bad complex number", 3)  
function P.add (c1, c2)  
 checkComplex(c1);  
 checkComplex(c2);  
return P.new(c1.r + c2.r, c1.i + c2.i)  
return P

local function checkComplex (c)  
if not ((type(c) == "table")  
and tonumber(c.r) and tonumber(c.i)) then 
 error("bad complex number", 3)  
local function new (r, i) return {r=r, i=i} end 
local function add (c1, c2)  
 checkComplex(c1);  
 checkComplex(c2);  
return new(c1.r + c2.r, c1.i + c2.i)  
complex = {  
 new = new,  
 add = add,  
 sub = sub,  
 mul = mul,  
 div = div,  
}

local location = {  
 foo = "/usr/local/lua/lib/pack1_1.lua",  
 goo = "/usr/local/lua/lib/pack1_1.lua",  
 foo1 = "/usr/local/lua/lib/pack1_2.lua",  
 goo1 = "/usr/local/lua/lib/pack1_3.lua",  
pack1 = {} 
setmetatable(pack1, {__index = function (t, funcname)  
local file = location[funcname]  
if not file then 
 error("package pack1 does not define " .. funcname)  
assert(loadfile(file))() 
-- load and run definition  
return t[funcname] 
-- return the function  
end})  
return pack1

function Account.withdraw (self, v)  
 self.balance = self.balance - v  
a1 = Account; Account = nil 
a1.withdraw(a1, 100.00) 
-- OK

function Account:withdraw (v)  
 self.balance = self.balance - v  
a:withdraw(100.00) 
Account = {  
 balance=0,  
 withdraw = function (self, v)  
 self.balance = self.balance - v  
function Account:deposit (v)  
 self.balance = self.balance + v  
Account.deposit(Account, 200.00)  
Account:withdraw(100.00)

function Account:new (o)  
 o = o or {} 
-- create object if user does not provide one  
 setmetatable(o, self)  
 self.__index = self  
return o  
a = Account:new{balance = 0}  
a:deposit(100.00)

local function search (k, plist)
for i=1, table.getn(plist) do
 local v = plist[i][k] -- try 'i'-th superclass
 if v then return v end
function createClass (...)
local c = {} -- new class
-- 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)
-- define a new constructor for this new class
function c:new (o)
 o = o or {}
 setmetatable(o, {__index = c})
return o
-- return new class
return c
--创建一个account类
Account = { }
function Account:deposit (v)
 self.balance = self.balance + v
function Account:withdraw (v)
 self.balance = self.balance - v
--创建一个类Named，Named 只有两个方法 setname and getname?
Named = {}
function Named:getname ()
return self.name
function Named:setname (n)
 self.name = n
--创建一个类,继承Account, Named
NamedAccount = createClass(Account, Named)
--创建一个Account类的对象
account = NamedAccount:new{name = "Paul",balance = 5} --一定要类创建对象时定义好name，balance，基类未调用不会定义
print(account:getname()) --> Paul
account:deposit(5)
print(account.balance) -->10

setmetatable(c, {__index = function (t, k)  
local v = search(k, arg)  
 t[k] = v 
-- save for next access  
return v  
end})

function newObject (value)  
return function (action, v)  
if action == "get" then return value  
elseif action == "set" then value = v  
else error("invalid action")

Lua:table与object

Lua:table与object

数据结构

队列和双向队列

字符串缓冲

元表与元方法

算数运算符元方法

库定义元方法

print(table)输出所有成员

表相关元方法

__index

__newindex

有默认值的表

监控表

只读表

环境

动态名字访问全局变量

声明全局变量

Packages

基本方法

私有成员

其他技巧

面向对象程序设计

类

面向对象new

继承

多重继承

单一方法