Lua

最新推荐文章于 2023-04-13 13:41:28 发布
LiErDan
最新推荐文章于 2023-04-13 13:41:28 发布
阅读量141
点赞数
分类专栏： Lua
本文链接：https://blog.csdn.net/LiErDan/article/details/109023817
版权
Lua 专栏收录该内容
2 篇文章 0 订阅
订阅专栏
--多重赋值
num1, num2 = 1, 2;
--print(num1,num2);
A = "hellow lua"; --变量定义
B = "占用内存空间用的";
B = nil; --清空占用内存
--print(A,B);

--变量作用域 do end 只用来定义语句块无他用, function, if 都是语句块
number = "100867";
do
    local number = "10086";
    --print(number); --10086
end
--print(number); --100867;


-- 判断变量类型type
temp = type(A)
--print(type(temp));
--print(type(123.2));

--多行字符串
Lines = [[
    <html>
        <head></head>
        <body><body>
    </html>
]]
--print(Lines);

--字符串连接
num = "1".."2";
--print(num); --12

--字符串类型转换
--print("1" + "2"); --3
--print(tostring(1).."2"); --"12"
--print(tonumber("8192")); --8192


--字符串长度
--print(#"strlength");
--print(string.len("abc"));

--字符串大小写转换
--print(string.upper("abc"));
--print(string.lower("BSD"));

--字符串查找
temp = string.find("abcdabcdabcd", "da", 5);
--print(temp); --8

--字符串截取, 不支持中文截取, 中文utf8占三个字节,一个汉字需要偏移3
temp = string.sub("abcdefg", 1, 3);
--print(temp); --abc
temp = string.sub("我们是共产主义接班人,继承革命先辈的光荣传统", 1,9);
--print(temp); --我们是

--字符串替换
temp = string.gsub("hellow beijing", "beijing", "shanghai");
--print(temp); --hellow shanghai

--字符串反转
temp = string.reverse("hellow");
--print(temp);

--字符串格式化
temp = string.format("格式化:%d--%s", 15, "十五");
--print(temp);

--数组,对象,表 为一物
ar = {
    1,
    2,
    3,
    20,
    theKey="keys",
    theValue="values",
    arFunction = function()
        --print("I'm in ar funciton");
    end
};
ar["forS"] = "s";
ar.outFunction = function()
    --print("In ar out function.");
end
function ar.outTestFunction()
    --print("In ar outTest function --"..self.theKey);
end
ar.outFunction();
ar.outTestFunction();

--self调用自己形式
function ar:inSelf()
    --print("In ar inSelf"..self.theKey);
end
ar:inSelf();

--省略调用函数的括号, 只有参数是字符串,或者(表数组对象,三者一个东西)时才可以
function ig(str)
    if(type(str) == "string") then
        --print(str);
    else
        for i, v in pairs(str) do
           --print(i, "--",v);
        end
    end

end
--ig  "省略参数";
--ig {"1","2", "3", kkk = "vvv"};

--print(ar["forS"]);
ar.forSS = "ss";
--print(ar.forS, ar["forSS"], ar.theKey, ar["theValue"]);
ar.arFunction();

--可变参数, arg对象中最后一个参数用来记录传递参数的个数, nil会影响计数, 但此属性被赋值nil, pairs遍历时忽略nil属性, ipairs遇到nil则中断遍历
function vars(a,...)
    --print(a);
    --print(type(arg));
    arg["test"] = nil;
    arg["test2"] = "null";
    for i, v in pairs(arg) do
        --print(i,v);
    end
end
vars("滴滴滴", "ls", "pwd", nil, nil,"echo", "666", "86");



for i, v in ipairs(ar) do
    --print(i, v);
end

for i, v in pairs(ar) do
    --print(i, v)
end
--数组下标的长度, 不包括键值
--print(#ar)
--print(table.getn(ar));

--数组连接成字符串, 只连接下标数组, 键值元素忽略
--print(table.concat(ar));
--print(table.concat(ar, "-"));
--print(table.concat(ar, "-", 2, 4));

--指定位置插入元素, 原位置元素后移, 不指定位置则插入到最后, 下标数组
table.insert(ar, 2, 100);
--table.insert(ar, "test2");

--移除元素, 下标数组
--table.remove(ar,3);
--table.remove(ar)

--数组排序, 下标数组
--table.sort(ar);

--print(table.concat(ar, "-"))
for i, v in pairs(ar) do
    --print(i, v)
end


--函数定义与调用
function test(a, b)
    --print("In function test. \n"..(a + b));
    return a + b, 755;
end
result, number = test(10086, 1);
--print(result, number);

function first(a, b)
    return a - b;
end
myFunction = first;
--print(myFunction(10, 1));

myFun = function (a, b, fun)
    local temp =  a * b;
    fun(temp);
end
function funMulti(temp)
    --print(temp);
end
myFun(2, 3, funMulti);

--内置函数
--print(math.abs(-1)); --绝对值
--print(math.max(10, 1, 5, 20, 100, 86)); --最大 100
--print(math.min(10, 1, 5, 20, 100, 86)); --最小 100
--math.randomseed(1000); --随机因子, 用于克制随机数的规定规律(第一次调用永远84),改变随机因子就可改变随机数规律
--print(math.random(0, 100)); --随机数
--print(math.random(0, 100)); --随机数
--print(math.floor(1.9)); -- 向下取整 1
--print(math.ceil(1.1)); --向上取整 2
--print(os.date()); --系统日期时间
--print(os.time()); --系统时间戳
--print(string.reverse(os.time()));

--闭包实现迭代器
function iterator(temp)
    index = 0;
    return function()
        index = index + 1;
        return temp[index];
    end
end

ar = {23,435,345, [20] = 100, 080,679, a = 11};
iter = iterator(ar);
for v in iter do
    --print(v);
end

--print(ar.a);
for i, v in pairs(ar) do
    --print(i,v);
end

--模块
--print(package.path); --打印默认require加载路径
sum = require("sum"); --加载模块
sum.operatorA = 3;
sum.operatorB = 2;
--print(sum.getSum());

--元表, 用来重新定义两个对象如何相加, 也可以定义其他操作符的行为, 相当于操作符重载
a = {1};
b = {2}
oldtable = {}
calculate = {
    __add = function(a, b)
        return a[1] + b[1];
    end,

    __unm = function(a) --一元操作符
        return "ls";
    end,

    __index = {[test] = "10086"},

    __newindex = oldtable,
}
setmetatable(a, calculate);
--print(a + b);
--print(-a);
--print(a[test]);

tempTable = setmetatable({},{
    __index = function(tempTable, key)
        if(key == 2) then
            return "Two";
        end
    end
});
--print(tempTable[2]);

-- __newindex设置数据时调用元方法
a[1] = "111";
a[2] = "222";
--print(a[1], oldtable[1]);
--print(a[2], oldtable[2]);

--协程
--第一种定义调用方法
--other = coroutine.create(
--  function(temp)
--          for i = 1, 10 do
--              print(i);
--              if(i == 3) then
--                  print(coroutine.status(other));
--                  print(coroutine.running());
--              end
--              print(coroutine.yield(10086));--协程挂起 yield会直接挂起当前协程, yield的返回值(返回给当前协程的返回值)是下一次唤醒当前协程时传递的参数,
--              --传入yield(这里的参数)括号内的参数会返回给调用者, 也就是coroutine.resume的返回值
--          end
--          print(temp);
--          coroutine.yield();
--          print(temp);
--      end
--);
--print(coroutine.status(other));
--print(coroutine.resume(other, "吼吼~","铛铛铛")); --true(resume调用成功默认返回值), 10086是调用coroutine.yield(10086)传入的参数
--print(coroutine.resume(other, "吼吼~ 滴滴滴")); --true 10086
--print(coroutine.resume(other, "滴滴滴"));
--print(coroutine.resume(other, "沥沥沥")); --第二次唤醒传入参数无效, 因为是延续上次唤醒时的代码地址执行, 沿用上次的堆栈参数
--print(coroutine.resume(other, "沥沥沥")); --唤醒失败 返回 false, 协程已经调用完毕不可再次唤醒


--另一种创建方式
--coroutineAsFunction = coroutine.wrap(
--    function(temp)
--        for i = 1, 2^29 do
--            if(i == 2^28) then
--                print(i);
--            end
--        end
--        print(temp);
--     end
--);
--coroutineAsFunction("155"); --这种方式同样只能调用一次

--运算符
--print(1 ~= 2); -- 比较 1 不等于 2  true
--print (1000 ~= 1000) --比较 1000 不等于 1000 false'
--print(1 < 2 and 3 < 2); --false 与
--print(1 < 2 and 3 > 2); --true 与
--print(1 < 2 or 3 < 2); --true 或
--print(not (1 < 2)); --取反
--print(10 and 20); --20

--文件操作
--fp = io.open("/usr/local/www/basic/a.txt", "r");
--print(fp:read());

--IO操作
--fp = io.open("/usr/local/www/basic/a.txt", "a");
--io.output(fp);
--io.write("\r\nall");
--io.close(fp);
--
--

--fp = io.open("/usr/local/www/basic/a.txt", "r");
--io.input(fp);
--temp = io.read()
--while(temp) do
--    print(temp);
--    temp = io.read();
--end
--io.close(fp);

--if语句
if(A == B)then
    --print("A == B");
elseif (false) then
    --print("In elseif true");
else
    --print("In elseif false");
end

--while循环
i = 0;
while(i < 100) do
    --print(i.."\n");
    i = i + 1;
end

--for循环 从1循环到10结束, <=10,
for i = 1, 10 do
    --print(i);  -- 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
end
-- for倒置循环, i = 1为开始标志, 1为结束标志, -1为步长
for i = 10, 1, -1 do
    --print(i);
end

--for循环键值数组
Ar = {'a', 'b','c'};
Ar["test1"] = 10086;
Ar["test2"] = 100867;

for i, v in ipairs(Ar) do
    --print(i, v);  -- 1,a 2,b 3,c
end

for k, v in pairs(Ar) do
    --print(k, v); --1,a 2,b 3,c test1,10086 test2,100867
end

--秒杀
function seckill(key1, key2)
    local user_id = key1;
    local product_id = key2;
    local qtkey = 'seckill:'..product_id..':kc';
    local users_key = 'seckill:'..product_id..':user'; --存储秒杀这个product_id商品的用户集合, 集合内容为user_id
    local userExists = redis.call('sismember', users_key, user_id); --判断上面的集合里存在当前user_id嘛
    if (tonumber(userExists) == 1) then
        return 2; --用户已经秒杀过了
    end

    local number = redis.call('get', qtkey);
    if(tonumber(number) <= 0) then
        return 0; --库存耗尽
    else
        redis.call('decr', 'qtkey');
        redis.call('sadd', users_key, user_id);
    end

    return 1; --抢购成功
end

result = seckill(KEYS[1], KEYS[2]);