程序员经验分享-hwhale

lua基础——基本语法

2023-10-27

类型

lua是动态类型语言，即变量的类型可以变。

通过type可以测试给定变量的类型，下面是例子：

[python]  view plain  copy
  1. print(type("helloworld"))   <span style="white-space:pre">    </span>-->string  
  2. print(type(1))              -->number  
  3. print(type(nil))            -->nil  
  4. print(type(true))           -->boolean  
  5. print(type(type))           -->function  
  6. print(type({x = 0, y = 1})) <span style="white-space:pre">    </span>-->table  
  7. co = coroutine.create(function()  
  8.     print("helloworld")  
  9. end)  
  10. print(type(co))             -->thread      
上面展示了lua的7个基本类型：

string number nil boolean function table thread。

另外还有一个类型是userdata，还不知道如何展示...

几点说明：

1. nil类型只有nil这么一个值。

2. boolean有两个值true和false。另外lua中的所有值都可以用在条件语句中，且除了false和nil表示假，其它都表示真。比如0，它表示真。

3. 数值类型只有number，没有int、float等类型。

4. string可以用双引号，也可以用单引号指定。还可以用[[里面是字符串]]，[[]]的特点是可以包含多行，可以嵌套，且不解释转移字符。

5. function和其他上述的类型一样，属于第一类值，就是说也可以存在普通的变量里面。

6. table、userdata和thread后面还会讲。


变量

变量不需要声明。

给一个变量赋值后就生成了一个全局变量。

[python]  view plain  copy
  1. print(a)    -->nil  
  2. a = 0  
  3. print(a)    -->0  
  4. a = "hello world"  
  5. print(a)    -->hello world  
  6. a = nil     -->删除a这个变量  

没有初始化的全局变量也可以访问，得到的是nil。实际的意思是，如果一个变量不是nil，就表示变量存在。所以如果给一个变量赋值为nil，就表示删除这个变量。

使用local关键字可以创建局部变量。

[python]  view plain  copy
  1. do  
  2. local a  
  3. end  
  4. print(a)    -->打印nil，因为a的生命周期已经结束  

局部变量只在被声明的那个代码块内有效。代码块可以是一个控制结构，一个函数体，或者一个chunk(变量被声明的那个文件或者字符串)。

lua中可以使用多变量赋值：

[python]  view plain  copy
  1. a,b,c = 1,"helloworld"  
  2. print(a)    -->1  
  3. print(b)    -->helloworld  
  4. print(c)    -->nil  

多变量赋值也不是很讲究，=右边如果比左边少，则相应的变量为nil，比如这里的c；=右边如果比左边少，则多出来的赋值会被忽略。

多变量赋值在函数返回时也很有用，因为lua中的函数是可以返回多个值的。


表达式

一些特别的点：

1. ~=相当于c语言里面的!=，不等于。

2. table、userdata和function是引用比较，只有两个变量指向同一个对象才是相等。

3. 逻辑运算符是"and or not"，但是这里的and和or意思跟c语言有不同：

a and b：如果a为false，则返回a，否则返回b；

a or b   ：如果a为true，则返回a，否则返回b。

4. “..”两个点，表示字符连接符；如果操作数是number，则转换为字符串：

[python]  view plain  copy
  1. print(1 .. 2)   -->12  

注意这里1 ..之间有一个空格，不然会报错。

但是如果是字符串就不需要：

[python]  view plain  copy
  1. print("hello".."world") -->helloworld  


表的构造

下面是基本例子：

[python]  view plain  copy
  1. table1 = {}     -->空表  
  2. names = {"jack", "john", "jimmy"}   -->列表形式初始化  
  3. print(names[1]) <span style="white-space:pre">    </span>-->jack,下标从1开始  
  4. names[4] = "jason"  
  5. print(names[4]) <span style="white-space:pre">    </span>-->jason  
  6. print(names[5]) <span style="white-space:pre">    </span>-->nil,因为不存在  
  7. a = {x = 0, y = 1}  -->record形式初始化  
  8. print(a.x)      -->0  
  9. print(a["x"])   <span style="white-space:pre">    </span>-->0,另一种表示方式  
  10. b = {"helloworld", x = 1, "goodbye"}    -->混合形式  
  11. print(b[1])     -->helloworld  
  12. print(b.x)      -->1  
  13. print(b[2])     -->goodbye  
  14. ---print(b.1)---没有这种  

表中分隔可以使用逗号，也可以使用分号。

还有一种更一般的形式：

[python]  view plain  copy
  1. a = {["+"] = "add", ["-"] = "sub", ["*"] = "mul", ["/"] = "div", }  
  2. print(a["+"])   <span style="white-space:pre">    </span>-->add  
  3. b = {[1] = "one", [2] = "two", [3] = "three"}  
  4. print(b[1])     -->one  

控制语句

IF语句：

if xxx then xxx end;

if xxx then xxx else xxx end;

if xxx then xxx elseif xxx then xxx else xxx end; //elseif可以有很多个，注意else和if中间没有空格！！

WHILE语句：

while xxx do xxx end;

REPEAT-UNTIL语句：

repeat xxx until xxx;

FOR语句：

for var=exp1,exp2,exp3 do xxx end; //这里for里面的语句意思是var以exp3为step，从exp1到exp2。

需要注意几点：

1. 几个exp只会运行一次，且在for循环之前；

2. var是局部变量；

3. 循环过程中不要改变var。

for x,y,z in xxx do xxx end;

BREAK和RETURN语句：

break退出当前循环；return退出函数并返回结果。

注意break和return只能用在一个block的结尾。如果有时候确实想要在另外的地方使用，可以用这样的方式：do break/return end;


函数

函数的定义：

[python]  view plain  copy
  1. function funcName (args)  
  2.     states;  
  3. end;  
关于函数调用时，如果没有参数，需要使用()；

如果参数是字符串或者表构造时，可以不用()。

lua函数中实参和形参的匹配也比较不讲究，实参多于形参，多余部分会忽略；实参少于形参，少的形参会是nil。这个与多变量赋值方式一致。

函数可以返回多个值：

[python]  view plain  copy
  1. function func (void)  
  2.     return 1,2  
  3. end;  
  4.   
  5. a,b = func()  
  6. print(a)    -->1  
  7. print(b)    -->2  

通过()可以是函数强制返回一个值：

[python]  view plain  copy
  1. function func (void)  
  2.     return 1,2  
  3. end;  
  4.   
  5. a,b = func()  
  6. print(func())   -->1 2  
  7. print((func())) -->1  
lua可以有可变参数。使用...三个点表示 ，在函数中用一个叫arg的table表示参数，arg中还有一个域n表示参数的个数。

下面是一个例子：

[python]  view plain  copy
  1. function func(...)  
  2.     -- local arg = {...}  
  3.     for i,v in ipairs({...}) do  
  4.         print(i,v)  
  5.     end  
  6. end;  
  7. func(0,1,2,3)  
打印的结果是：

1 0

2 1

3 2

4 3

函数参数传递时可以使用表的形式，这样就不需要记太多的参数，如下面的例子：

[python]  view plain  copy
  1. -->不需要特别创建函数func(new, old)  
  2. function func (args)  
  3.     print(args.new,args.old)  
  4. end  
  5. var = {new = 1, old = 2}  
  6. func(var)  

函数实际上也是变量，因此可以有另外一种表达方式，比如下面两种方式：

[python]  view plain  copy
  1. function foo(x) return 2 * x end  
[python]  view plain  copy
  1. foo = function (x) return 2 * x end  

它们其实是一样的。第二个foo被称为第一类值函数，将它应用在表中是lua面向对象和包机制的关键。

函数中还可以包含函数，这个内部的函数可以访问包含它的那个函数中的变量(包括参数)，下面是一个例子：

[python]  view plain  copy
  1. -->定义了一个返回函数的函数  
  2. function NewCounter()  
  3.     local i = 0  
  4.     return function()  
  5.         i = i + 1  
  6.         return i  
  7.     end  
  8. end  
  9. c1 = NewCounter()   -->c1是被返回的函数，需要注意的是它捕获了NewCounter()中的i变量  
  10. print(c1()) -->1  
  11. print(c1()) -->2  
  12. c2 = NewCounter()  
  13. print(c2()) -->1 -->c2是一个新的返回函数，它捕获的还是原来的i，所以打印的是1  

这里的内部函数以及它能够访问到的(捕获的)变量，共同构成了称为"闭包(closure)"的概念。

典型的闭包包含两个部分，一个是闭包自己，另一个是工厂(创建闭包的函数)。

lua中的函数是变量，因此它可以是全局变量后者局部变量。作为局部变量的例子，比如说表中的域(像io.read这种，read就是一个局部函数)：

[python]  view plain  copy
  1. Lib = {}    -->定义一个表  
  2. Lib.add = function(x, y) return x + y end   -->创建两个局部变量  
  3. Lib.sub = function(x, y) return x - y end  
  4.   
  5. print(Lib.add(1,1)) -->2  
  6. print(Lib.sub(1,1)) -->0  
表中的局部函数还有两中形式可以表示：

第二种：

[python]  view plain  copy
  1. Lib = {  
  2.     add = function(x, y) return x + y end,  -->分隔符别忘了  
  3.     sub = function(x, y) return x - y end  
  4. }   -->定义一个表  
  5. print(Lib.add(1,1)) -->2  
  6. print(Lib.sub(1,1)) -->0  
第三种：

[python]  view plain  copy
  1. Lib = {}  
  2. function Lib.add(x, y) return x + y end  
  3. function Lib.sub(x, y) return x - y end  

另外，在函数前面声明local就得到局部函数：

[python]  view plain  copy
  1. do  
  2. local foo = function(x)  
  3.     print(x)  
  4. end  
  5. local function goo(x)  
  6.     print(x)  
  7. end  
  8.   
  9. foo(1)  
  10. goo(2)  
  11. end  
  12. -->foo(1)    报错，访问不到了  
  13. -->goo(2)    报错，访问不到了  
声明局部函数的时候需要注意递归的情况：

[python]  view plain  copy
  1. local func    
  2. -->因为有两个地方要声明，如果只在第一个位置，即function前面声明local，  
  3. -->后面的func(x - 1)位置就会识别不出来它是局部的，所以去找全局的了，  
  4. -->结果没有找到就会报错，所以这里要做前向声明  
  5.   
  6.   
  7. func = function (x)  
  8.     if x == 0 then  
  9.         return 1  
  10.     else  
  11.         return x * func(x - 1)  
  12.     end  
  13. end  
  14. print(func(3))  
另外lua中的函数还支持“正确的尾调用”，它像下面的样子：

[python]  view plain  copy
  1. function f(x)  
  2.   return g(x)  
  3. end  
在这里g的调用就是尾调用，这种情况下，实际上g返回时不需要返回到调用者f中，所以不需要在栈中保留调用者f的任何信息。而正确的尾调用就是指lua能够使尾调用时确实不使用额外的信息，这相当于一个goto到了另外的函数。

正确的尾调用使得递归可以无限进行而不会导致栈的溢出，当然也不只是在递归中，其它多个函数之间的调用也不需要担心栈溢出。

但是需要注意尾调用的形式，像下面这些就不是尾调用：

[python]  view plain  copy
  1. function f()  
  2.   g()  
  3.   return   
  4. end  
  5. return g(x) + 1  
  6. return x or g(x)  
  7. return (g(x))  


迭代器和泛型for

lua中的迭代器常用函数来描述迭代器，每次调用该函数就返回集合的下一个元素。

下面是一个例子：

[python]  view plain  copy
  1. function IterFactory(t) -->创建迭代器的工厂  
  2.     local i = 0  
  3.     local n = #t    -->获取表的长度，只对列表形式的有效  
  4.     return function()   -->这个是迭代器  
  5.         i = i + 1  
  6.         if i <= n then  
  7.             return t[i]  
  8.         end  
  9.     end  
  10. end  
  11.   
  12. aTable = {"one", "two", "three"}  
  13. f = IterFactory(aTable)  
  14. print(f())  -->one  
  15. print(f())  -->two  
  16. print(f())  -->three  
  17. print(f())  -->不打印  
上面的例子其实跟《函数》一章中的闭包例子没有多大的差别。这个主要要讲的是下面这种和泛型for一起使用的情况：

[python]  view plain  copy
  1. function IterFactory(t) -->创建迭代器的工厂  
  2.     local i = 0  
  3.     local n = #t    -->获取表的长度，只对列表形式的有效  
  4.     return function()   -->这个是迭代器  
  5.         i = i + 1  
  6.         if i <= n then  
  7.             return t[i]  
  8.         end  
  9.     end  
  10. end  
  11.   
  12. aTable = {"one", "two", "three"}  
  13. for element in IterFactory(aTable) do  
  14.     print(element)  
  15. end  
泛型for的格式是下面这样的：

[python]  view plain  copy
  1. for <var-list> in <exp-list> do  
  2.   <body>  
  3. end  
其中，var-list的第一个变量称为控制变量，如果它是nil，循环终止；exp-list通常是一个迭代工厂的调用，就像前面的IterFactory(aTable)。

泛型for循环的执行过程如下：

1. 计算in后面表达式的值，这个表达式返回三个值，分别是迭代函数，状态常量和控制变量，如果返回的不够，就用nil来补充。

2. 将状态常量和控制变量作为参数调用迭代函数。(对于for循环，状态常量没有用，仅仅在初始化时获取它的值并传递给迭代函数)

3. 将迭代函数返回的值赋值给变量列表。

4. 如果返回的第一个值是nil，循环结束，否则执行循环体；

5. 回到第二步再次调用迭代函数。

所以说，上面的泛型for可以解释称下面的伪代码：

[python]  view plain  copy
  1. do  
  2.     local _f, _s, _var = exp-list  
  3.     while true do  
  4.         local var_1, ..., var_n = _f(_s, _var)  
  5.         _var = var_1  
  6.         if _var == nil then  
  7.             break  
  8.         end  
  9.         <block>  
  10.     end  
  11. end  


编译/运行/调试

首先介绍chunk的概念：

chunk是一系列的代码。lua执行的每一个块代码，比如一个文件或者交互模式下(命令行下运行lua不加参数，就会进入交互模式)的每一行都是一个chunk。

chunk可以是一个语句(比如：交互模式下的一行，do end内部只有一行的话也算)，可以是一系列的语句(比如do end内部，或者for循环内部)，还可以是函数。

下面介绍几个函数：

dofile()：用来连接外部的chunk，它加载文件并执行它。下面是一个例子：

[python]  view plain  copy
  1. dofile("iterator.lua")  
这里的"iterator.lua“是放置上一章节例子的文件，通过dofile()就可以运行它的代码。

dofile是lua运行代码的一种原始操作，它只是辅助作用，真正完成功能的是loadfile()函数。

loadfile()：它编译代码成中间码并且返回编译后的chunk作为函数，但不执行代码。

注意lua语言也有编译这个动作，虽然它被称为脚本语言，但是lua的编译器是语言运行时的一部分，所以执行编译并生成中间码的动作非常快。

另外，loadfile()不会抛出错误信息而是返回错误码，当发生错误时，loadfile()返回nil和错误信息。

与loadfile()很相似的有一个loadstring()：

loadstring()：从一个字符串中读入代码并编译成函数。

[python]  view plain  copy
  1. f = loadstring("i = 1; print(i)")  
  2. f() -->这里才是执行，前面只是生成了函数  
或者简写成：

[python]  view plain  copy
  1. loadstring("i = 1; print(i)")() -->注意后面的括号  

loadstring()和loadfile()一样，不会抛出错误，但是会返回nil和错误信息，下面是一个例子：

[python]  view plain  copy
  1. print(loadstring("i i"))  
它打印如下的错误信息：


需要注意的一点，loadstring()总是在全局环境下编译字符串，所以它只认全局的变量而看不到局部变量：

[python]  view plain  copy
  1. local i = 0  
  2. loadstring("print(i)")()    -->nil  

还有一个跟dofile()类似的函数是require()：

require()：它用来加载运行库。与dofile的主要区别是以下几点：

1. require()会搜索目录加载文件。

2. require()会判断是否文件已经加载以避免重复加载同一文件。

关于第一个区别：require()搜索的路径采用模式列表的形式，比如如下的形式：

?;?.lua;/usr/local/lua/?/?.lua

在实际的操作中，比如require("helloworld")，则参数代替模式中的?，并搜寻代替后的文件：helloworld;helloworld.lua;/usr/local/lua/helloworld/helloworld.lua

下面是一个例子：


实际上它运行了helloworld.lua文件。

需要注意这里的路径保存在LUA_PATH这个全局变量中，但是它也不一定存在，如果不存在，就用默认的"?;?.lua"。

关于第二个区别：lua中有一个表记录所有已经加载了得文件，但是需要注意表中保存的是文件的虚名，即参数名字。因此如果使用require("helloworld")和require("helloworld.lua")，那么实际上还是会加载两次helloworld.lua文件，而不是一次。

error()：结束程序并返回错误信息。下面是一个例子：


assert()：接受两个参数，第一个参数如果不为真，就调用error(第二个参数表示的信息)。

pcall()：封装可能的错误代码(错误代码被放在函数中，或者包装成一个匿名函数)，用来进行错误处理。如果没有错误，返回true和调用函数的返回值，否则返回false加错误信息。

下面是一个例子：

[python]  view plain  copy
  1. -->可能出错的代码封装在函数内  
  2. function func()   
  3.     error() -->抛出错误  
  4. end  
  5. -->pcall调用函数  
  6. if pcall(func) then   
  7.     print("no error")  
  8. else  
  9.     print("error")  
  10. end  
上述的代码打印error。

不仅是错误信息，当发生错误的时候，所有传递给error()的参数都会被pcall()返回：

[python]  view plain  copy
  1. -->可能出错的代码封装在函数内  
  2. function func()   
  3.     error({code = 404}) -->抛出错误  
  4. end  
  5. -->pcall调用函数  
  6. local status, err = pcall(func)  
  7. if status == false then   
  8.     print(err.code)  
  9. end  
打印结果：404。

协程coroutine

协程跟线程类似，不同的是同一时间可以跑多个线程，但是协程只能有一个在运行。

协程通过协作来完成，lua里面就是resume()和yeild()。

协程需要运行的代码被封装在函数中，通过将函数名传递给create()函数作为参数来创建一个协程，当然也可以直接传递匿名函数当作参数。

下面是一个例子：

[python]  view plain  copy
  1. co = coroutine.create(  
  2.         function ()  
  3.             print("helloworld")  
  4.         end  
  5.     )  
  6. print(co)   -->thread: 0xxxxx(某个16位地址)  
协程有三个状态：挂起态，运行态，停止态。

协程被创建后处于挂起态。也就是说协程并不会自动运行。

通过协程的status()来查看状态：

[python]  view plain  copy
  1. co = coroutine.create(  
  2.         function ()  
  3.             print("helloworld")  
  4.         end  
  5.     )  
  6. print(coroutine.status(co)) -->suspended  

通过resume()可以使协程进入运行态，之后代码结束就进入了停止态：

[python]  view plain  copy
  1. co = coroutine.create(  
  2.         function ()  
  3.             print(coroutine.status(co))  
  4.         end  
  5.     )  
  6. coroutine.resume(co)    -->running  
  7. print(coroutine.status(co)) -->dead  

通过yield()可以将协程挂起：

[python]  view plain  copy
  1. co = coroutine.create(  
  2.     function ()  
  3.         for i=1,10 do  
  4.             print("co", i)  
  5.             coroutine.yield()  
  6.         end  
  7.     end  
  8.     )  
  9. coroutine.resume(co)  
  10. print(coroutine.status(co)) -->suspended   
运行结果如下：

如果之后再运行resume()：

[python]  view plain  copy
  1. coroutine.resume(co)  
  2. coroutine.resume(co)  
  3. coroutine.resume(co)  
  4. coroutine.resume(co)  
运行结果如下：

当调用次数超过10次之后：

[python]  view plain  copy
  1. print(coroutine.resume(co))  
运行结果如下：

resume()和yield()之间可以传递参数，见下面的示例：

示例一，resume()的参数传递给了协程：

[python]  view plain  copy
  1. co = coroutine.create(  
  2.     function (a, b, c)  
  3.         print("co", a, b, c)  
  4.     end  
  5.     )  
  6. coroutine.resume(co, 1, 2, 3)   -->resume的参数传递到了协程中  

示例二，yield()的参数也将传递给resume()：

[python]  view plain  copy
  1. co = coroutine.create(  
  2.     function(a, b)  
  3.         coroutine.yield(a + b, a - b)  
  4.     end  
  5.     )  
  6. print(coroutine.resume(co, 20, 10))  

运行结果中，true表示resume()运行成功，后面的30和10是yield的参数。

示例三，协程代码返回值也会传递给resume()：

[python]  view plain  copy
  1. co = coroutine.create(  
  2.     function(a, b)  
  3.         return a + b, a - b  
  4.     end  
  5.     )  
  6. print(coroutine.resume(co, 20, 10))  
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

lua

lua基础

lua基础——基本语法 的相关文章

  • 无法在cmake中使用find_package找到Lua标头

    我正在尝试使用 CMake 为我使用 Lua 的项目构建生成 make 文件 当我运行 make 时出现此错误 path to my project luaudio luaudio c 1 17 fatal error lua h No s

  • 如何加载目录中的所有文件？

    正如标题所说 如何加载目录中的每个文件 我对c 和lua都感兴趣 编辑 对于 Windows 我很高兴能得到一些真正的工作代码 尤其是 lua 我可以用 boost filesystem for c 来做 对于 Lua 你需要模块Lua文件

  • 迭代包括空行在内的行

    给定一个带有一些空行的多行字符串 我如何在Lua中迭代行包括空行 local s foo nbar n njim for line in magiclines s do print line and blank or line end gt

  • Lua 和序列化闭包

    我正在尝试序列化和反序列化 Lua 闭包 我的基本理解是下面的工厂应该生成闭包 并且Lua在函数和闭包之间没有太多区别 即没有类型 闭包 gt function ffactory x return function return x end

  • Lua - 尝试调用全局（零值）

    执行此代码时 出现错误 尝试调用全局 forId 零值 function execute args local itemid 526 local bone forId itemid this is where the error occur

  • 了解静态链接嵌入式lua环境中lua扩展dll的构建/加载

    我有一个相对复杂的 lua 环境 我试图了解以下内容如何工作 起始设置包括以下两个模块 主要应用 无lua环境 DLL 静态链接到lua lib 包括解释器 该 dll 被加载到主应用程序中 并运行 lua 控制台解释器和可从控制台访问的

  • Lua：冒号符号、“自我”和函数定义与调用

    我对定义 调用 Lua 函数时使用的冒号表示法感到非常困惑 我以为我已经明白了 直到我看到这段代码 function string PatternSafe str return str gsub pattern escape replace

  • Lua中如何获取目录列表

    我需要 LUA 中的目录列表 假设我的目录路径为 C Program Files 我需要该特定路径中所有文件夹的列表以及如何搜索该列表中的任何特定文件夹 Example 需要路径 C Program Files 中所有文件夹的列表 以下是上

  • Lua中如何对数字表求和？

    Lua有内置的吗sum 功能 我似乎找不到一个 我几乎翻遍了文档中的所有地方 或许table sum 或类似的东西 以遵循当前的约定 但由于我找不到它 我不得不实现它 function sum t local sum 0 for k v i

  • 如何解密Lua字节码？

    早上好 我正在尝试破译 Moon 字节码 但我无法以任何方式 有人可以帮助我吗 我有这个 例如 code 27 76 117 97 81 0 1 4 4 4 8 0 如何将此字节码解密为文本 我已经在这里搜索 http www asciit

  • lua http套接字超时

    LuaSocket HTTP 模块文档说可以在 HTTP 连接上设置超时 可以设置以下常量来控制 HTTP 模块的默认行为 PORT 用于连接的默认端口 PROXY 用于连接的默认代理 TIMEOUT 设置所有I O操作的超时时间 USER

  • 如何在 Lua 中实现 OO？

    Lua 没有内置对 OO 的支持 但它允许您自己构建它 您能否分享一些实现面向对象的方法 请为每个答案写一个例子 如果您有更多示例 请发布另一个答案 我喜欢将 OOP 视为容器 对象 内的数据封装以及可以使用该数据完成的操作子集 还有很多内

  • Lua :: 如何编写加载多个CPU的简单程序？

    我还无法用 Lua 编写一个可以加载多个 CPU 的程序 自从Lua通过协程支持这个概念 http www lua org pil 9 4 html 我相信这是可以实现的 我失败的原因可能是以下之一 这在Lua中是不可能的 我写不出来 an

  • 检查多个位置的值并仅在源唯一时返回匹配项

    假设我有一个清单Vendors 阿斯达 乐购 Spar 我有一个清单Sources 或者这个类比中的供应商 家乐氏 Kellogg 吉百利 Cadbury 雀巢 Nestle 强生 Johnsons 帮宝适 Pampers Simple 等

  • Lua 将字符串转换为数字 - 取决于语言环境

    刚刚注意到字符串 and tonumber 在 Lua 中是依赖于语言环境的 知道如何在不使用的情况下将字符串转换为数字tonumber 谢谢 例如将字符串 58 5 转换为 58 5 另外 当我尝试将带点的数字传递给函数时 该函数会转换

  • 比较 Lua 中的日期

    我有一个带有日期表的变量 如下所示 table day number 15 year number 2015 month number 2 如何获取当前日期与上述日期之间的天数 非常感谢 您可以使用os time 将表转换为秒并获取当前时间

  • 如何在我的 Lua 脚本中添加“睡眠”或“等待”？

    我正在尝试通过更改一天中的时间来为游戏制作一个简单的脚本 但我想快速完成 这就是我要说的 function disco hour minute setTime 1 0 SLEEP setTime 2 0 SLEEP setTime 3 0

  • 如何终止Lua脚本？

    如何终止 Lua 脚本 现在我在 exit 方面遇到问题 我不知道为什么 这更像是一个 Minecraft ComputerCraft 问题 因为它使用了包含的 API 这是我的代码 while true do if turtle dete

  • 如何让我的 add 命令找到第一个变量和第二个变量的值，然后将它们加在一起？

    vars values function open file lex file end function lex file local data io open file r for char in data lines do Print

  • Lua 上的 For 循环

    我的作业是如何执行 for 循环 我已经从数字上弄清楚了 但无法从名称上弄清楚 我想创建一个 for 循环来运行名称列表 以下是我到目前为止所拥有的 names John Joe Steve for names 1 3 do print n

随机推荐

  • NodeMCU-32S-内部DAC音频输出测试

    NodeMCU 32S 内部DAC音频输出测试 文章目录 NodeMCU 32S 内部DAC音频输出测试 前言 硬件说明 软件编译 测试 ESP32 DAC参考链接 前言 一直想玩玩ESP32的蓝牙音频功能 手上面有一个NodeMCU 32

  • DAY02: 编程入门03- 核心代码解析

    1 Arduino默认提供的两个方法 setup 方法 用于初始化 程序一开始 只运行一次 用于定于引脚为OUTPUT还是INPUT loop 方法 循环不停得执行 用于编写小车移动旋转等一直需要命令的代码 2 小车电机运动的核心方法 定于

  • ESP8266 NodeMCU 擦除闪存执行出厂重置

    在本教程中 我们将了解如何在 Windows Linux 和 MacOS 中使用 esptool py 命令行实用程序擦除 ESP8266 的闪存 并讨论为什么以及何时需要执行此操作 与任何电子设备一样 有时您可能需要将 ESP8266 重

  • 学校报名登记收缴费用小程序开发制作

    报名登记收缴费用小程序 适合培训机构 幼儿园 小学 高中 初中 大学等学校 报名登记小程序 微信扫码登记 手机端登记报名信息 数据发送至管理后台 管理员可查阅数据列表 完成了学生报名信息收集 审核 修改 复审 收费 等多项复杂功能 收费可以

  • 蜣螂优化(DBO)算法附MATLAB代码

    目录 一 蜣螂优化 DBO 算法灵感来源 二 蜣螂优化 DBO 算法设计 三 蜣螂优化 DBO 算法MATLAB部分代码 四 运行结果 蜣螂优化 Dung Beetle Optimizer DBO 算法是2022年11月27日提出的 大家可

  • Sentinel服务熔断和降级

    还记得我们前所说的服务降级吗 也就是说我们需要在整个微服务调用链路出现问题的时候 及时对服务进行降级 以防止问题进一步恶化 那么 各位是否有思考过 如果在某一时刻 服务B出现故障 可能就卡在那里了 而这时服务A依然有大量的请求 在调用服务B

  • 29. Divide Two Integers

    这题 Given two integers dividend and divisor divide two integers without using multiplication division and mod operator Re

  • UnityVR--机械臂场景5-记录角度自动旋转

    机械臂已经能够在示教模式下单步旋转了 下一步 我们可以将每个关节旋转的角度记录下来 让机械臂自动旋转到指定位置 1 在UI画布上增加两个按钮 recordButton和AutoButton 一个用来记录每个节点旋转的角度 另一个让机械臂自动

  • 【算法修炼】优先队列

    优先队列 一 最后一块石头的重量 简单 二 数组中两元素的最大乘积 简单 三 根据字符出现频率排序 中等 四 找到和最大的长度为k的子序列 简单 优先队列 也称为堆 Heap 它可以在保证队列的结构下 对队列的内部元素进行排序 可以按照某个

  • Windows上通过CMake编译COLMAP源码操作步骤

    COLMAP源码 https github com colmap colmap 最新的稳定版本位于master分支 最新的开发版本位于dev分支 这里使用master分支进行编译 commit id为1555ff0 官方推荐使用vs2019

  • 高速计数器学习

    S7 1200 CPU 提供了最多 6 个 1214C 高速计数器 其独立于 CPU 的扫描周期进行计数 可测量的单相脉冲频率最高为 100KHz 双相或 A B 相最高为 30KHz 除用来计数外还可用来进行频率测量 高速计数器可用于连接

  • LeetCode刷题复习

    内容参考CyC大佬的LeetCode复习指南 算法思想复习 在考虑更优解时 先从数据状况入手 一般C 1s可以运行 1 0 7 1 0 8 10 7 10 8 107 108次 看有何特点可以利用 如有序 回文 重复 推公式等 1 1双指针

  • spring boot 如何配置Logback

    在 Spring Boot 项目中 Logback 是默认的日志框架 要配置 Logback 你需要创建一个名为 logback spring xml 的配置文件并将其放在项目的 src main resources 目录下 以下是一个详细

  • Unity设置物体旋转角度误区

    小白欢迎评论 共同探讨 共同进步 第一篇Unity的博文 这篇很短 接下来会陆续更新笔记本上之前记得坑 在这里有一个小误区 一般新手都非常容易出的错误 设置物体位置我们都是给transform position赋值 那么问题来了 设置物体的

  • ubuntu 12.04新安装好后需要进行的包升级和清理工作

    根据这么多次的操作经验 我发现 ubuntu系统在新安装好后需要进行一些包的升级和清理工作 不然的话 后续安装各种软件都不顺畅 会出现各种各样的问题 需要进行的包升级和清理工作其实很简单 只需要执行以下两条命令即可 apt get f in

  • 视觉slam g2o 编译出现 Cmake Error：By not providing “FindG2O.cmake““G2OConfig.cmake“ in CMAKE_MODULE_PATH错误

    第一步 这时需要在cmakelist文件中更改几行代码 代码如下 将LIST APPEND CMAKE MODULE PATH PROJECT SOURCE DIR cmake list APPEND CMAKE MODULE PATH X

  • Datawhale 李宏毅机器学习 Task2

    一 回归的定义和举例 定义 Regression 就是找到一个函数 function 通过输入特征 x 输出一个数值 Scalar 举例 股市预测 输入 过去10年股票的变动 新闻咨询 公司并购咨询等 输出 预测明天股市的平均值 自动驾驶

  • 【牛客网】BC146 添加逗号

    一 题目描述 牛客网题目链接 添加逗号 牛客题霸 牛客网 描述 对于一个较大的整数 N 1 lt N lt 2 000 000 000 比如 980364535 我们常常需要一位一位数这个数字是几位数 但是如果在这 个数字每三位加一个逗号

  • 在区块链里打模组化新概念，ALL要彻底实现技术融合并不容易！

    点击上方 蓝色字 可关注我们 编辑 铅笔盒 在今年的达沃斯论坛上 区块链与AI 3D打印等技术一起被列为第四次科技革命的重要技术 有人质疑加密货币 但几乎没有人否认区块链 可以预见接下来的一段时间所有焦点都将聚集在这个行业 区块链技术并不成

  • lua基础——基本语法

    类型 lua是动态类型语言 即变量的类型可以变 通过type可以测试给定变量的类型 下面是例子 python view plain copy print type helloworld

热门标签