Lua语法学习 - 技术栈

Lua

文章目录

- - - Lua
    - - 变量
      - 数据类型
      - nil
        
        boolean
        
        string
        
        table
      - 循环
      - if
      - 函数
      - 运算符
      - Table

lua 复制代码

-- Events
local StateEvents = ReplicatedStorage:WaitForChild("StateEvents");
local AddMoneyEvent = StateEvents:WaitForChild("AddMoneyEvent");



AddMoneyEvent:FireServer(score*10);

区分大小写

单行注释 --

ctrl+Q 然后在罗布乐思编辑器里面好像是ctrl+？

lua 复制代码

--[[
print('多行注释')

--]] 
---[[
print('取消多行注释')
--]]

变量

在默认情况下，变量总是认为是全局的。(除非用 local 显式声明为局部变量)全局变量不需要声明，给一个变量赋值后即创建了这个全局变量，访问一个没有初始化的全局变量也不会出错，只不过得到的结果是：nil。

lua 复制代码

> print(b)
nil
> b=10
> print(b)
10
>

如果你想删除一个全局变量，只需要将变量赋值为nil。这样变量b就好像从没被使用过一样。换句话说, 当且仅当一个变量不等于nil时，这个变量即存在。

Lua 对多个变量同时赋值，不会进行变量传递，仅做值传递：

遇到赋值语句Lua会先计算右边所有的值然后再执行赋值操作

lua 复制代码

a, b = 0, 1
a, b = a+1, a+1
print(a,b)               --> 1   1
a, b = 0, 1
a, b = b+1, b+1
print(a,b)               --> 2   2
a, b = 0, 1
a = a+1
b = a+1
print(a,b)               --> 1   2

数据类型

Lua 是动态类型语言，变量不要类型定义,只需要为变量赋值。

Lua 中有 8 个基本类型分别为：nil、boolean、number、string、userdata、function、thread 和 table。

number: 表示双精度类型的实浮点数

string:可由一对单引号或双引号表示

fuction:由C或Lua编写的函数

userdata:表示任意存储在变量中的C数据结构

thread:表示执行的独立线路，用于执行协同程序

table:Lua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字、字符串或表类型。在 Lua 里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。

nil

nil 类型表示一种没有任何有效值，它只有一个值 -- nil

nil 作比较时应该加上双引号，因为type(X) 实质是返回的 "nil" 字符串，是一个 string 类型

lua 复制代码

> type(X)
nil
> type(X)==nil
false
> type(X)=="nil"
true
>

boolean

boolean 类型只有两个可选值：true（真）和 false（假），Lua 把 false 和 nil 看作是 false，其他的都为 true，数字 0 也是 true:

string

字符串由一对双引号或单引号来表示。

也可以用 2 个方括号 "[[]]" 来表示"一块"字符串。

lua 复制代码

html = [[
<html>
<head></head>
<body>
    <a href="http://www.runoob.com/">菜鸟教程</a>
</body>
</html>
]]
print(html)


--执行结果是
--[[
<html>
<head></head>
<body>
    <a href="http://www.runoob.com/">菜鸟教程</a>
</body>
</html>
--]]

在对一个数字字符串上进行算术操作时，Lua 会尝试将这个数字字符串转成一个数字:

\> print("2" + 6) 8.0 \> print("2" + "6") 8.0

反过来，当 Lua 期望一个 string 而碰到数字时，会将数字转成 string。

print(10 .. 20) --> 1020

... 在Lua中是字符串连接符，当在一个数字后面写 ... 时，必须加上空格以防止被解释错。

使用 # 来计算字符串的长度，放在字符串前面

使用 # 输出的值其实是字符串所占的字节数。当字符串为英文字符时，由于每个字符只占 1 个字节，所以输出结果等同于字符串长度

len = "www.runoob.com" print(#len) 14 print(#"www.runoob.com") 14

table

不同于其他语言的数组把 0 作为数组的初始索引，在 Lua 里表的默认初始索引一般以 1 开始。

t[i] --对 table 的索引使用方括号 []。Lua 也提供了 . 操作。

t.i --当索引为字符串类型时的一种简化写法

lua 复制代码

a = {}
a["key"] = "value"
key = 10
a[key] = 22
a[key] = a[key] + 11
for k, v in pairs(a) do
    print(k .. " : " .. v)
end

lua里面的print自动换行的

lua 复制代码

tab1={key1="1","2"}
print(tab1[1])--输出2
--前面那个不知道为什么不算进去了,因为不规范吗还是啥
--print(tab1.key1) 此时输出1

循环

while循环

lua 复制代码

while(condition)
do
   statements
end

for循环

lua 复制代码

for var=exp1,exp2,exp3 do  
    <执行体>  
end

var 从 exp1 变化到 exp2，每次变化以 exp3 为步长递增 var，并执行一次 "执行体"。exp3 是可选的，如果不指定，默认为1

for的三个表达式在循环开始前一次性求值，以后不再进行求值。比如上面的f(x)只会在循环开始前执行一次，其结果用在后面的循环中。

lua 复制代码

function f(x)  
    print("function")  
    return x*2  
end  
for i=1,f(5) do print(i)  
end

--[[
function
1
2
3
4
5
6
7
8
9
10
-]]

泛型for循环

lua 复制代码

--打印数组a的所有值  
a = {"one", "two", "three"}
for i, v in ipairs(a) do
    print(i, v)--print 先输出i 然后输出几个空格然后是v
end

在lua中pairs与ipairs两个迭代器的用法相近，但有一点是不一样的：

pairs可以遍历表中所有的key，并且除了迭代器本身以及遍历表本身还可以返回nil;但是ipairs则不能返回nil,只能返回数字0，如果遇到nil则退出。它只能遍历到表中出现的第一个不是整数的key

在table的key是字典的时候，好像就必须要用pairs

repeat...until

lua 复制代码

a=10
repeat
   print("a的值为:", a)
   a = a + 1
until( a > 15 )

--[[
a的值为:    10
a的值为:    11
a的值为:    12
a的值为:    13
a的值为:    14
a的值为:    15
--]]

和 do while差不多，但是他是在条件为true时退出循环的

lua 中没有 continue 语句有点不习惯。

可以使用类似下面这种方法实现 continue 语句：

lua 复制代码

for i = 10, 1, -1 do
  repeat
    if i == 5 then
      print("continue code here")
      break
    end
    print(i, "loop code here")
  until true
end

if

lua 复制代码

if(布尔表达式)
then
   --[ 在布尔表达式为 true 时执行的语句 --]
end

lua 复制代码

if(布尔表达式)
then
   --[ 布尔表达式为 true 时执行该语句块 --]
else
   --[ 布尔表达式为 false 时执行该语句块 --]
end

lua 复制代码

if( 布尔表达式 1)
then
   --[ 在布尔表达式 1 为 true 时执行该语句块 --]

elseif( 布尔表达式 2)
then
   --[ 在布尔表达式 2 为 true 时执行该语句块 --]

elseif( 布尔表达式 3)
then
   --[ 在布尔表达式 3 为 true 时执行该语句块 --]
else 
   --[ 如果以上布尔表达式都不为 true 则执行该语句块 --]
end

函数

lua 复制代码

optional_function_scope function function_name( argument1, argument2, argument3..., argumentn)
    function_body
    return result_params_comma_separated
end

optional_function_scope: 该参数是可选的制定函数是全局函数还是局部函数，未设置该参数默认为全局函数，如果你需要设置函数为局部函数需要使用关键字 local。
function_name: 指定函数名称。
argument1, argument2, argument3..., argumentn: 函数参数，多个参数以逗号隔开，函数也可以不带参数。
function_body: 函数体，函数中需要执行的代码语句块。
result_params_comma_separated: 函数返回值，Lua语言函数可以返回多个值，每个值以逗号隔开。

Lua 中我们可以将函数作为参数传递给函数，如下实例：

lua 复制代码

function myprint(param)
   print("这是打印函数 -   ##",param,"##")
end

function add(num1,num2,functionPrint)
   result = num1 + num2
   -- 调用传递的函数参数
   functionPrint(result)
end
myprint(10)
-- myprint 函数作为参数传递
add(2,5,myprint)

返回多个结果值

lua 复制代码

function maximum (a)
    local mi = 1             -- 最大值索引
    local m = a[mi]          -- 最大值
    for i,val in ipairs(a) do
       if val > m then
           mi = i
           m = val
       end
    end
    return m, mi
end

print(maximum({8,10,23,12,5}))

可变参数

在函数参数列表中使用三点 ... 表示函数有可变的参数。

lua 复制代码

function add(...)  
local s = 0  
  for i, v in ipairs{...} do   --> {...} 表示一个由所有变长参数构成的数组  
    s = s + v  
  end  
  return s  
end  
print(add(3,4,5,6,7))  --->25

lua 复制代码

sum=0
cnt=0;
function verage(...)
    --sum=0
	--cnt=0
	for i,v in ipairs{...} do
	sum=sum+v
	cnt=cnt+1
	--print(i)
	end
	--print(cnt,sum)
	return sum/cnt;
end

print(cnt)--这为什么是0啊，全局变量？？ 然后如果把cnt定义放在函数内部的话输出nil
print(verage(1,2,3,4,5))

lua 复制代码

function ave(...)
	local sum=0
	for i,v in ipairs{...} do
	sum=sum+v
	end
	a=select(3,...)
	print(a)--输出3
	print(select(3,...))--输出3  4  5  6  7
	return sum
end

print(ave(1,2,3,4,5,6,7))--输出28

select('#', ...) 返回可变参数的长度。
select(n, ...) 用于返回从起点 n 开始到结束位置的所有参数列表。但是如果直接打印的话，只会打印第一个参数

注意一下多返回值的函数在赋值时的情况，仅仅只有放在所有逗号之后的那个函数会把返回值展开

lua 复制代码

function add()
return 1,0
end

local a,b,c,d=add(),add()
print(a,b,c,d)--输出 1  1  0  nil

运算符

// 整除运算符，计算结果不包含小数部分

/ 除法运算，计算结果包含小数部分

~= 不等于

and 逻辑与

or 逻辑或

not 逻辑非

.. 连接两个字符串

# 一元运算符,返回字符串或表的长度

lua 复制代码

tab3={}--没有这一行就报错欸
tab3[1]="1"
tab3[2]="2"
tab3[5]="5"
print("tab3的长度",#tab3)--输出2
--如果数组有一个"空洞" （就是说，nil 值被夹在非空值之间）， 那么 #t 可能是指向任何一个是 nil 值的前一个位置的下标 （就是说，任何一个nil 值都有可能被当成数组的结束）。



tab4={}
tab4[1]="1"
tab4[2]=nil
tab4[3]="2"
tab4[4]=4
print(#tab4)--输出4，按理来说应该是1,应该是因为上面说的是可能,没有很清楚不是很懂。。。。。。。。

Table

在 Lua 索引值是以 1 为起始，但你也可以指定 0 开始。除此外我们还可以以负数为数组索引值

lua 复制代码

for i=-2,2 do
   array[i]=i*10
end

for i=-2,2 do
   print(array[i])
end

lua 复制代码

local a={1,2,3,4,5}
local b=a[1]
print(a[1] .. ' ' .. b)
a[1]=nil
print(a[1])
print(b)
--输出
1 1
nil
1

b的值还是原来的不会变成nil

插入insert

table.insert(表名,位置,值)

位置默认是最后一位

移除remove

table.remove(表名,位置)

假设移除表的最后一个元素 table.remove(table,#table)

排序

teble.sort(表名,方法) 默认升序

lua 复制代码

local a={1,2,language="english",3,4,5,text="hello"}

table.foreach(a,function(i,v)
print(i,v)
end)

table.foreachi(a,function(i,v)
print(i,v)
end)


--输出
1	1
2	2
3	3
4	4
5	5
language	english
text	hello
1	1
2	2
3	3
4	4
5	5

foreach 会把最后索引不是数字的输出

而foreachi 不会输出那些key是非数字的