lua笔记二

1. 表与表的运算
2. 抽象表的创建与继承

--[[
require "model"		--把公有的代码放在一个文件夹，可以以API的方式在其他地方调用，相当于引用命名空间

print(model.var);
model.han();

--model.fun1();		--local函数相当于 私有不可调用

fun2();				--可直接调用模块里的函数 和参数名字
print(b);
--]]


--[[
mytable={"c#","lua","java"} --普通表
mymetatable={}				--元表
print(mytable)

mytable=setmetatable(mytable,mymetatable)[1];		--调用表内第一个值返回

print(mytable)

print(mymetatable)
print(getmetatable(mytable))

--]]
--[[

mytable={"java","lua","c#"}

settable={
__index=function()							--当键所对应的值不存在时调用 __index;制定函数就 调用，指定表则更 新表
	return "noll";						    --当查找没有的键时；
end
};

mytable=setmetatable(mytable,settable);


print(mytable[10]);

--]]

--[[

mytable={"java","lua","c#"}


settable={

	__newindex=function(tab,key,value)		--当给一个没有的索引赋值时，调用__newindex
	rawset(tab,key,value);
	end

};

mytable[10]="45";
print(mytable[10]);

--]]


--[[

mytable={"java","lua","c#"}



newtable={"newtable"};


settable={

	__newindex=newtable				--当修改一个新的索引时，调用__newindex

};
mytable=setmetatable(mytable,settable);
newtable[1]="ff";
newtable[5]="gg"
newtable[112]="45";
print(mytable[112]);
print(mytable[1]);
print(mytable[5]);

--]]


--[[
mytable={"java","lua","c#"}

myset={
	__add=function(tab,newtable)
		local mi=0;
		for v,k in pairs(tab) do
			if(v>mi) then
				mi=v;
			end
		end
		print(mi,#tab);
		for v,k in pairs(newtable) do
			mi=mi+1;
			table.insert(tab,mi,k);
		end
		return tab;
	end

}
mytable=setmetatable(mytable,myset);
newtable={"newtable"};


v1=mytable+newtable;

for k,v in pairs(mytable) do
	print(k,v);
end
--]]


--[[
mytable={"java","lua","c#"}

myset={
	__add=function(tab,newtable)			  --表与表的运算
		local mi=0;
		for v,k in pairs(tab) do
			if(v>mi) then
				mi=v;
			end
		end
		print(mi,#tab);
		for v,k in pairs(newtable) do
			mi=mi+1;
			table.insert(tab,mi,k);
		end
		return tab;
	end,								    --表里两个函数用，隔离

	__call=function(tab,s1,s2,s3)			--__call当把这个表当作一个函数来用时；
	print(s1+s2+s3);

	end,

	__tostring=function(mytable)			--__tostring当把一个表当作字符串来使用输出时
		str=""
		for k,v in pairs(mytable) do
			str=str..v.."\n";
		end

		return str;

	end

}
mytable=setmetatable(mytable,myset);
newtable={"newtable"};

print(mytable(123,34,340));

print(mytable);


--]]

--[[

co=coroutine.create(						--create创建，resume继续,启动
	function(a,b)

		print(coroutine.status(co));		--调用时runn
		print(coroutine.running());
		print(a+b)

		coroutine.yield();
		print(2);
		print(coroutine.status(co));
		print(coroutine.running());
		return a/b;						--create创建会先return ture/false

	end

)
print(coroutine.status(co));				--调用前暂停（函数外不会是运行的）
print(coroutine.running());
s1,s2,s3=coroutine.resume(co,20,50);		--调用协程 函数
print(s1,s2,s3);


po=coroutine.wrap(							--wrap包裹，调用的格式要不一样;
	function(a,b)
		print(a-b)
		coroutine.yield(a/b);				--yield可以return参数
		print(a+b)
		return a/b;						--wrap创建会return
	end

);

res1,res2,res3=po(20,30);
print("siki")
print(res1,res2,res3)
--po();

coroutine.resume(co,50,60);					--第二次调用co
print(coroutine.status(co));				--函数结束return后函数dead

--]]

--[[
file=io.open("x2.txt","r+");
--io.input(file);
--io.output(file);							--设置file为默认输出文件

--file:write("\n6666");
print(file:read())							--完全模式(不用设置文件流，要关闭)
file:close()
--print(io.read("*l"));

--print(io.read());
--io.close(file);




file =io.open("x2.txt","a+");				--以读写的方式打开txt;
--io.output(file);							--设置file为默认输出文件

--io.write("\n6666");

io.input(file);								--设置file为默认输入文件
print(io.read())

io.close(file);


--]]

--[[

tab={"apple","org","banana"};

print(collectgarbage("count"))

tab=nil;

print(collectgarbage("count"))

print(collectgarbage("collect"))

print(collectgarbage("count"))

--]]



--person={name="siki"}

--[[
person.eat=function ()
	print(person.name.."在吃饭");
end


person.eat()

--]]

--[[
function person:eat()
	print(self.name.."sss")
end
--]]
--[[
a=person;
a:eat();						--通过：定义方法可以持有当前table为self
--person:eat();

--]]
---------------------------------------------------------------
--[[

Person={name="siki"}					--抽象类

function Person:eat()					--在table表里 定义一个key eat;的函数
	print(self.name.."eat dinner");
end
										--持有当前table为self(构造函数)
function Person:new()					--再新建一个key new函数
	t={};								--函数值为t表 ，定义一个虚表，设置为t表的元表
	setmetatable(t,{ __index=self})		--设置self为index__,有self是指定表则更新表
	return t							--调用new 就是t,t为空，不存在时调用元表index,等于调用self
end

person=Person:new();					--继承抽象类
print(person.name)

person.name="bb";						--更新父类元素值

print(person.name)

t.kk="kk";
print(t.kk);
print(Person.kk)

v1={"c1"};
v2={"c2"};

v1=setmetatable(v1,{__newindex=v2})			--__newindex是v2,调用v1时如果没有就掉用v2 查找或者更新

--v1.kk="kk";
print(v1.kk)
print(v2.kk)

--]]
--[[

Person={name="siki"}					--抽象类

function Person:eat()					--在table表里 定义一个key eat;的函数
	print(self.name.."eat dinner");
end
										--持有当前table为self(构造函数)
function Person:new(o)					--再新建一个key new函数
	t=o or {};								--函数值为t表 ，定义一个虚表，设置为t表的元表
	--setmetatable(t,{ __index=self})		--设置self为index__,有self是指定表则更新表

	setmetatable(t,self);			    --设置Persono
	self.__index=self;					--设置修改的表为person

	return t							--调用new 就是t,t为空，不存在时调用元表index,等于调用self
end

person=Person:new({kk="cc"});					--继承抽象类
print(person.name)
print(person.kk)

--]]
----------------------------------------------------------------

Person={name="siki",age="66"}
function Person:new(o)
	local t=o or {}
	setmetatable(t,{__index=self})		--查找
	return t;
end

Student=Person:new();
Student.jj="jj";
print(Student.jj);
print(Person.jj)
Student.grade=2;
Teacher=Person:new();
Teacher.Title="seniorTea";


stu1=Student:new();
tea1=Teacher:new();


stu1.bb="kk";
print(stu1.bb)
print(Person.bb)
print(stu1.grade);
print(tea1.Title)