--Test
-- print("my name is AK!")
-- print("180301")
-- function TestFunction( b )
-- a=b
-- print(b,type(b))
-- end
-- TestFunction("b type:")
-- str1='single'
-- str2="double"
-- str3=[[
-- a block
-- a block
-- a block
-- ]]
-- print(str1,str2,str3)
-- print(str3)
-- print("1"+2) -- 转数字类型进行计算
-- print("1"+"2") -- 转数字类型进行计算
-- print("1+2") -- 输出的是字符串
-- value=11
-- print("value="..value)
-- mail = "[email protected]"
-- print(#mail)-- 使用 # 计算字符串长度
-- =============================================================================================================
-- print("180301")
--[[18
03
01]]
-- 基础语法知识点
-- (1)注释: 单行注释 "--"
-- 多行注释 "--[[" 内容 "--]]",可以使用多个单行注释,实现多行注释
-- 单行注释的快捷方式 : Ctrl + ?
-- (2)lua代码的执行快捷方式 : Ctrl + B
-- (3)变量和命名规范, 避免使用下划线 + 大写字母的方式 例:_BBC 方式耦合.
-- (4)避免使用 "%" "$" "@" 等特殊字符定义成员,区分大小写
-- (5)无需对变量约束类型,赋值的同时就约定了对应的类型
-- (6-1)访问一个没有初始化的全局变量也不会出错,只不过得到的结果是:nil.
-- (6-2)可以设置一个变量为 nil
-- (7)使用 type 函数,输出成员变量的数据类型
-- (8)使用 "" '' 单引号或者双引号,表示一个字符串.还可以使用 [[]] 表示一块字符串
-- (9)对一个数字字符串上进行算术操作时，Lua 会尝试将这个数字字符串转成数字类型进行计算
-- (10-1)字符串拼接,使用 ".." 两个点对字符串进行拼接
-- (10-2)使用 # 计算字符串长度,需要放到字符串类型变量的前面 ex : print(#mail)
-- ======= Table 表 ======
-- (11-1)表的第一种写法(类似于 C# 数组)
-- lua 表的下标(索引)从 1 开始
-- _table_1={"apple","orange",1,9,"a"}
-- print(_table_1[0])
-- (11-2)表的第二种写法(类似于 C# 字典,有键值对应)
-- _table_2={x="apple",y="orange",z=1}
-- print(_table_2.x)
-- print("_table_2:x=".._table_2.x)
-- 键值表取值的方式,类似于调用成员,使用 "表名" + "." + "键值" 取值
-- (12-1)字符串键的表赋值
-- _table_3={}
-- _table_3["str_key"]="str_value"
-- 错误的写法:
-- _table_3={"str_key="str_value"}
-- (12-2)字符串键的表的取值有两种
-- print(_table_3.str_key)--第一种取值方式
-- print(_table_3["str_key"])--第二种取值方式
-- (13)表赋值
-- _table_4={}
-- _table_4[1]="intvalue"
-- print(_table_4[1])
-- (14)for循环 第一个值 是自增变量的初始值. 第二个值 是自增变量的目标.
-- 第三个值 是步长(每次循环结束后初始值增加多少)
-- 默认步长是隐藏的,并且默认为一
-- for i=1,10 do
-- print(i)
-- end
-- for i=1,10,2 do
-- print('--')
-- print(_table_1[i])
-- end
-- (15-1)lua 迭代器
-- 以下是数组类型的表 两种迭代器无差别
-- _table_5={"x_value","y_value","z_value"}
-- for i,v in ipairs(_table_5) do
-- print(i,v)
-- end
-- for k,v in pairs(_table_5) do
-- print(k,v)
-- end
-- (15-2)
-- _table_6={a="x_value",b="y_value",c="z_value"}
-- for k,v in pairs(_table_6) do
-- print("**")
-- print(k,v)
-- end
-- for i,v in ipairs(_table_6) do
-- print("--")
-- print(i,v)
-- end
-- 两种迭代器的差别是 pairs 迭代表元素
-- ipairs 迭代数组元素
-- pairs 可以迭代数组类型和键值对应的表
-- 而 ipairs 仅仅能迭代数组类型的表元素
-- 二者都可以迭代索引从 1 开始表元素
-- 表赋值
-- _table_8={}
-- _table_8.a="apple" -- 表赋值
-- 取值
-- print(_table_8.a)
-- print(_table_8["a"])
-- print(_table_8[a]) -- 错误的写法:不报错,会返回 "nil"
-- (16)函数
-- 函数定义
-- function my_fun_01()
-- print("run : my_fun_01")
-- end
-- my_fun_01()
-- function my_fun_02(arg1,arg2)
-- return arg1+arg2
-- end
-- print(my_fun_02(2,3))
-- (16-2) 函数赋值给变量,变量可以当做函数来调用
-- self_func = my_fun_02
-- print(self_func(9,1))
--(17)以匿名函数的方式,通过参数传递
-- function anonymous_func(tab_arg,func_arg)
-- for k,v in pairs(tab_arg) do
-- print(func_arg(k,v))
-- end
-- end
-- _table={a="a_value",b="b_value",c="c_value"}
-- anonymous_func(_table,function (_key,_value)
-- return _key,_value
-- end)
-- (18) 表函数(把一个函数作为一个表的元素)
-- 使用 ":" 冒号来定义表函数
-- _table={x="x_value",y="y_value"}
-- 定义表函数
-- function _table:tabFunc(arg1,arg2)
-- _table.x=arg1
-- _table.y=arg2
-- end
-- print(_table.x)
-- print(_table.y)
-- 调用表函数
-- _table:tabFunc("new_x.value","new_y.value")
-- print(_table.x)
-- print(_table.y)
-- (18-2) 使用 "." 点号定义表函数
-- tab={}
-- function tab.tabFunc()
-- print(1+2)
-- end
--调用表函数,使用 "." 调用表函数
-- tab.tabFunc()
-- tab:tabFunc()
-- 两种定义表函数的差别,使用 ":"(冒号) 和 "."(点号)
-- tab_a = {a=1,b=3}
-- function tab_a:tab_a_Func( ... ) -- 使用 ":" 定义的
-- print(self.a,self.b)
-- end
-- tab_a:tab_a_Func()
-- tab_a.tab_a_Func() -- 这种写法错误
-- ":" 会将调用者 (表) 以匿名的形式传入表函数
-- "." 不会传递调用者
-- (19) 一维数组 数组的索引从 1 开始
-- myArray = {"a","b","c"}
-- for i=1,3 do
-- print(myArray[i])
-- end
-- 数组的索引可以是负数
-- array_a={}
-- for i=-3,-1 do
-- array_a[i]=i*2
-- end
-- for i=-3,-1 do
-- print(array_a[i])
-- end
-- (20) 多维数组
-- array_b={}
-- for i=1,3 do
-- array_b[i]={}
-- for j=1,10 do
-- array_b[i][j]=i*j
-- end
-- end
-- 读取多维数组
-- for i=1,3 do
-- for j=1,3 do
-- print(array_b[i][j])
-- end
-- end
-- 补充 表赋值 key 和 value 支持不同类型
-- tab={}
-- tab[1]="a_value" -- 数字 key (索引) 字符串 Value
-- print(tab[1])
-- tab["2"]=2 -- 字符串 Key , 数字 Value
-- (21) 将表 a 赋值给表 b 表示 a 和 b 指向的是相同的内存地址
-- tab_a={"11","22"}
-- tab_b=tab_a
-- 如果设置 a 为空, b 依然可以访问元素
-- tab_a=nil
-- print(tab_b[1])
-- (22) 表元素处理的相关函数
-- <1> Concat 连接方法
-- tab_a={"lan","ou"}
-- temp=table.concat(tab_a)
-- print(temp)
-- <2> insert 插入
-- tab_b={"a","b","c"}
-- table.insert(tab_b,"d") -- 默认插入到表的结尾处
-- print(tab_b[#tab_b]) -- 使用 # 获取表长度,作为索引,打印最后一个元素
-- 指定插入的位置
-- 通过 insert 函数的第二个参数指定插入的位置(索引位置)
-- table.insert(tab_b,2,"ff")
-- print(tab_b[2])
-- <3> remove 移除方法
-- 默认是移除最后一个元素
-- tab_c={"a","b","c","d"}
-- print(tab_c[#tab_c])
-- table.remove(tab_c)
-- print(tab_c[#tab_c])
-- print(tab_c[1])
-- table.remove(tab_c,1) -- 第二个参数指定移除的元素索引
-- print(tab_c[1])
-- <4> sort 排序函数
-- tab_s={"a","d","f","e","c","b"}
-- table.sort(tab_s)
-- for i=1,#tab_s do
-- print(tab_s[i])
-- end
-- (23) if 语句
value_a = 1
-- if(value_a<5)
-- then
-- print("判断的值小于 5",value_a)
-- else
-- print("判断的值大于等于 5",value_a)
-- end
if (value_a > 6)
then
print("判断值大于 6")
elseif
(value_a>3)
then
print("判断值大于 3")
else
print("判断值不大于 6,也不大于3")
end
-- print("my name is AK!")
-- print("180301")
-- function TestFunction( b )
-- a=b
-- print(b,type(b))
-- end
-- TestFunction("b type:")
-- str1='single'
-- str2="double"
-- str3=[[
-- a block
-- a block
-- a block
-- ]]
-- print(str1,str2,str3)
-- print(str3)
-- print("1"+2) -- 转数字类型进行计算
-- print("1"+"2") -- 转数字类型进行计算
-- print("1+2") -- 输出的是字符串
-- value=11
-- print("value="..value)
-- mail = "[email protected]"
-- print(#mail)-- 使用 # 计算字符串长度
-- =============================================================================================================
-- print("180301")
--[[18
03
01]]
-- 基础语法知识点
-- (1)注释: 单行注释 "--"
-- 多行注释 "--[[" 内容 "--]]",可以使用多个单行注释,实现多行注释
-- 单行注释的快捷方式 : Ctrl + ?
-- (2)lua代码的执行快捷方式 : Ctrl + B
-- (3)变量和命名规范, 避免使用下划线 + 大写字母的方式 例:_BBC 方式耦合.
-- (4)避免使用 "%" "$" "@" 等特殊字符定义成员,区分大小写
-- (5)无需对变量约束类型,赋值的同时就约定了对应的类型
-- (6-1)访问一个没有初始化的全局变量也不会出错,只不过得到的结果是:nil.
-- (6-2)可以设置一个变量为 nil
-- (7)使用 type 函数,输出成员变量的数据类型
-- (8)使用 "" '' 单引号或者双引号,表示一个字符串.还可以使用 [[]] 表示一块字符串
-- (9)对一个数字字符串上进行算术操作时，Lua 会尝试将这个数字字符串转成数字类型进行计算
-- (10-1)字符串拼接,使用 ".." 两个点对字符串进行拼接
-- (10-2)使用 # 计算字符串长度,需要放到字符串类型变量的前面 ex : print(#mail)
-- ======= Table 表 ======
-- (11-1)表的第一种写法(类似于 C# 数组)
-- lua 表的下标(索引)从 1 开始
-- _table_1={"apple","orange",1,9,"a"}
-- print(_table_1[0])
-- (11-2)表的第二种写法(类似于 C# 字典,有键值对应)
-- _table_2={x="apple",y="orange",z=1}
-- print(_table_2.x)
-- print("_table_2:x=".._table_2.x)
-- 键值表取值的方式,类似于调用成员,使用 "表名" + "." + "键值" 取值
-- (12-1)字符串键的表赋值
-- _table_3={}
-- _table_3["str_key"]="str_value"
-- 错误的写法:
-- _table_3={"str_key="str_value"}
-- (12-2)字符串键的表的取值有两种
-- print(_table_3.str_key)--第一种取值方式
-- print(_table_3["str_key"])--第二种取值方式
-- (13)表赋值
-- _table_4={}
-- _table_4[1]="intvalue"
-- print(_table_4[1])
-- (14)for循环 第一个值 是自增变量的初始值. 第二个值 是自增变量的目标.
-- 第三个值 是步长(每次循环结束后初始值增加多少)
-- 默认步长是隐藏的,并且默认为一
-- for i=1,10 do
-- print(i)
-- end
-- for i=1,10,2 do
-- print('--')
-- print(_table_1[i])
-- end
-- (15-1)lua 迭代器
-- 以下是数组类型的表 两种迭代器无差别
-- _table_5={"x_value","y_value","z_value"}
-- for i,v in ipairs(_table_5) do
-- print(i,v)
-- end
-- for k,v in pairs(_table_5) do
-- print(k,v)
-- end
-- (15-2)
-- _table_6={a="x_value",b="y_value",c="z_value"}
-- for k,v in pairs(_table_6) do
-- print("**")
-- print(k,v)
-- end
-- for i,v in ipairs(_table_6) do
-- print("--")
-- print(i,v)
-- end
-- 两种迭代器的差别是 pairs 迭代表元素
-- ipairs 迭代数组元素
-- pairs 可以迭代数组类型和键值对应的表
-- 而 ipairs 仅仅能迭代数组类型的表元素
-- 二者都可以迭代索引从 1 开始表元素
-- 表赋值
-- _table_8={}
-- _table_8.a="apple" -- 表赋值
-- 取值
-- print(_table_8.a)
-- print(_table_8["a"])
-- print(_table_8[a]) -- 错误的写法:不报错,会返回 "nil"
-- (16)函数
-- 函数定义
-- function my_fun_01()
-- print("run : my_fun_01")
-- end
-- my_fun_01()
-- function my_fun_02(arg1,arg2)
-- return arg1+arg2
-- end
-- print(my_fun_02(2,3))
-- (16-2) 函数赋值给变量,变量可以当做函数来调用
-- self_func = my_fun_02
-- print(self_func(9,1))
--(17)以匿名函数的方式,通过参数传递
-- function anonymous_func(tab_arg,func_arg)
-- for k,v in pairs(tab_arg) do
-- print(func_arg(k,v))
-- end
-- end
-- _table={a="a_value",b="b_value",c="c_value"}
-- anonymous_func(_table,function (_key,_value)
-- return _key,_value
-- end)
-- (18) 表函数(把一个函数作为一个表的元素)
-- 使用 ":" 冒号来定义表函数
-- _table={x="x_value",y="y_value"}
-- 定义表函数
-- function _table:tabFunc(arg1,arg2)
-- _table.x=arg1
-- _table.y=arg2
-- end
-- print(_table.x)
-- print(_table.y)
-- 调用表函数
-- _table:tabFunc("new_x.value","new_y.value")
-- print(_table.x)
-- print(_table.y)
-- (18-2) 使用 "." 点号定义表函数
-- tab={}
-- function tab.tabFunc()
-- print(1+2)
-- end
--调用表函数,使用 "." 调用表函数
-- tab.tabFunc()
-- tab:tabFunc()
-- 两种定义表函数的差别,使用 ":"(冒号) 和 "."(点号)
-- tab_a = {a=1,b=3}
-- function tab_a:tab_a_Func( ... ) -- 使用 ":" 定义的
-- print(self.a,self.b)
-- end
-- tab_a:tab_a_Func()
-- tab_a.tab_a_Func() -- 这种写法错误
-- ":" 会将调用者 (表) 以匿名的形式传入表函数
-- "." 不会传递调用者
-- (19) 一维数组 数组的索引从 1 开始
-- myArray = {"a","b","c"}
-- for i=1,3 do
-- print(myArray[i])
-- end
-- 数组的索引可以是负数
-- array_a={}
-- for i=-3,-1 do
-- array_a[i]=i*2
-- end
-- for i=-3,-1 do
-- print(array_a[i])
-- end
-- (20) 多维数组
-- array_b={}
-- for i=1,3 do
-- array_b[i]={}
-- for j=1,10 do
-- array_b[i][j]=i*j
-- end
-- end
-- 读取多维数组
-- for i=1,3 do
-- for j=1,3 do
-- print(array_b[i][j])
-- end
-- end
-- 补充 表赋值 key 和 value 支持不同类型
-- tab={}
-- tab[1]="a_value" -- 数字 key (索引) 字符串 Value
-- print(tab[1])
-- tab["2"]=2 -- 字符串 Key , 数字 Value
-- (21) 将表 a 赋值给表 b 表示 a 和 b 指向的是相同的内存地址
-- tab_a={"11","22"}
-- tab_b=tab_a
-- 如果设置 a 为空, b 依然可以访问元素
-- tab_a=nil
-- print(tab_b[1])
-- (22) 表元素处理的相关函数
-- <1> Concat 连接方法
-- tab_a={"lan","ou"}
-- temp=table.concat(tab_a)
-- print(temp)
-- <2> insert 插入
-- tab_b={"a","b","c"}
-- table.insert(tab_b,"d") -- 默认插入到表的结尾处
-- print(tab_b[#tab_b]) -- 使用 # 获取表长度,作为索引,打印最后一个元素
-- 指定插入的位置
-- 通过 insert 函数的第二个参数指定插入的位置(索引位置)
-- table.insert(tab_b,2,"ff")
-- print(tab_b[2])
-- <3> remove 移除方法
-- 默认是移除最后一个元素
-- tab_c={"a","b","c","d"}
-- print(tab_c[#tab_c])
-- table.remove(tab_c)
-- print(tab_c[#tab_c])
-- print(tab_c[1])
-- table.remove(tab_c,1) -- 第二个参数指定移除的元素索引
-- print(tab_c[1])
-- <4> sort 排序函数
-- tab_s={"a","d","f","e","c","b"}
-- table.sort(tab_s)
-- for i=1,#tab_s do
-- print(tab_s[i])
-- end
-- (23) if 语句
value_a = 1
-- if(value_a<5)
-- then
-- print("判断的值小于 5",value_a)
-- else
-- print("判断的值大于等于 5",value_a)
-- end
if (value_a > 6)
then
print("判断值大于 6")
elseif
(value_a>3)
then
print("判断值大于 3")
else
print("判断值不大于 6,也不大于3")
end