Lua语法学习

Lua

文章目录

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

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



AddMoneyEvent:FireServer(score*10);

区分大小写

单行注释 --

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

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

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

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

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

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

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 类型

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

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

string

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

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

html = [[



    菜鸟教程


]]
print(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 --当索引为字符串类型时的一种简化写法

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自动换行的

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

while循环

while(condition)
do
   statements
end

for循环

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

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

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

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循环

--打印数组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

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 语句:

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
if(布尔表达式)
then
   --[ 在布尔表达式为 true 时执行的语句 --]
end
if(布尔表达式)
then
   --[ 布尔表达式为 true 时执行该语句块 --]
else
   --[ 布尔表达式为 false 时执行该语句块 --]
end
if( 布尔表达式 1)
then
   --[ 在布尔表达式 1 为 true 时执行该语句块 --]

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

elseif( 布尔表达式 3)
then
   --[ 在布尔表达式 3 为 true 时执行该语句块 --]
else 
   --[ 如果以上布尔表达式都不为 true 则执行该语句块 --]
end
函数
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 中我们可以将函数作为参数传递给函数,如下实例:

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

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

返回多个结果值

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}))

可变参数

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

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
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))
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 开始到结束位置的所有参数列表。但是如果直接打印的话,只会打印第一个参数

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

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 逻辑非

.. 连接两个字符串

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

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 开始。除此外我们还可以以负数为数组索引值

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

for i=-2,2 do
   print(array[i])
end
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(表名,方法) 默认升序

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是非数字的

你可能感兴趣的:(lua,学习,junit)