lua基本语法
lua是一种脚本语言,它的执行效率大概是C的10倍左右，而现在风头正盛的python
执行效率大概是C的100倍 所以Lua也有自己的一番天地,游戏的脚本中就大量的使用
Lua语言,因为最近在搞使用脚本语言来做嵌入式开发,所以先从Lua入手。
我在windows上所使用的开发环境是Lua for windows这款IDE直接安装即可是使用
无需配置环境,Lua的版本是Lua 5.1.5,虽然Lua更新了新版，增加了对UTF-8编码的支持,
但是5.1.5的效率更高使用也更广泛。
不喜欢Lua for windows的编辑器的,也可以用sublime配置,用起来更舒服一些。
流程控制
cond 条件
doSomething 执行函数
var 变量
begin 起始量
finish 结束量
step 步进值
if条件
local x = 1 --局部变量关键字标志 修饰局部变量
局部变量可与全局变量同名
if flag then
doSomething()
else
if flag then
doSomething()
elseif status then
doSomething()
else
doSomething()
end
while循环
while cond do
doSomething()
end
repeat 循环
repeat
doSomething()
until cond
for循环
for var = begin,finish,step do
doSomething()
end
for if 嵌套
for i = begin,finish do
if i == 3 then
break
end
doSomething()
end
return 主要用于函数结果
function sum(x,y)
return x+y
end
local sum = sum(1,1)
print(sum)
运算符与函数
== 等于 判断相等
~= 不等于
> 大于
< 小于
>= 大于等于
<= 小于等于
% 取余
^ 乘幂
- 负号
and 逻辑与
or 逻辑或
not 逻辑非
.. 连接字符串
# 返回字符串长度 print(#str1)
运算符优先级
^ not#- */% +- .. <><=>===~= and or
字符串
local str1 = 'hello world'
local str2 = "hello world"
local str3 = [[hello world]]
字符串操作
string.upper(str) 将字符串转为大写
string.lower(str) 将字符串转为小写
string.gsub(sourceStr,findStr,replaceStr,num) 替换字符串
string.find(str,substr,[init,[end]]) 在指定字符串中搜索指定字符串
string.reverse(str) 字符串反转
string.format(...) 返回一个格式化的字符串
string.char(args) 返回整数所对应的ASCII码字符串
string.byte(str[,int]) 返回字符串对应的ASCII码 int为从几个开始
string.byte("abc",1,3) -->97 98 99
string.len(str) 计算字符串的长度
string.rep(str,n) 返回字符串的第n次拷贝
string.gmatch(str,pattern) 返回一个迭代器 遍历str中出现pattern的地方
string.match(str,pattern,init) 字符串中匹配模式字符串pattern若匹配成功则返回
匹配成功字符串，若没有则返回nil，init表示从第
几个开始匹配
string.sub(s,i,[,j]) 返回字符串s 索引i到j之间的字符串
string.gsub(s,p,r[,n]) 将s中所有子串p替换成字符串r n表示现在替换次数
string.format()格式化所涉及格式
%c 将一个数字转化为ASCII码中对应的字符
%d,%i 将一个数字转化为有符号的整数
%o 将数字转化为八进制格式
%u 将数字转化为无符号整数
%x 将数字转化为十六进制格式 小写字母
%X 将数字转化为十六进制格式 大写字母
%e 将数字转化为科学计数法格式 小写字母
%E 将数字转化为科学计数法格式 大写字母
%f 将数字转化为浮点型格式
%s 将数字转化为浮点型格式
eg.print(string.format("%d",2.3))
使用示例
--1、string.upper(str)转换为大写
print(string.upper("hello Lua"))
-->HELLO LUA
-------------------------------------
--2、string.lower(str)转换为小写
print(string.lower("HELLO"))
-->hello
-------------------------------------
--3、string.gsub(sourceStr,findStr,replaceStr,num)替换指定字符串
print(string.gsub("hello lua","l","L",2))
-->heLLo lua 2
-------------------------------------
--4、string.find(str, substr, [init, [end]])查找字符串
print(string.find("hello lua","lua",3))
-->7 9
-------------------------------------
--5、string.reverse(str) 反转字符串
print(string.reverse("Lua"))
-->auL
6、string.format(…)
print(string.format("%f" , 20))
-->20.000000
-------------------------------------
print(string.format("%d" , 2.3))
-->2
-------------------------------------
print(string.format("%o" , 10))
-->12
--7、string.char(args)
print(string.char(97))
-->a
-------------------------------------
--8、string.byte(str[,int]) 如果后边的int为空则默认1
print(string.byte("abc" , 1 ,3))
-->97 98 99
--如果上例没有1，3则只输出97
-------------------------------------
--9、string.len(str)字符串长度
print(string.len("hello Lua"))
-->9
-------------------------------------
--10、string.rep(str, n) 返回字符串n次拷贝
print(string.rep("abc" , 3))
-->abcabcabc
-------------------------------------
--11、string.gmatch(str, pattern)
for w in string.gmatch("hello lua" , "%a+") do
print("=======" , w)
end
-------------------------------------
--12、string.match(str, pattern, init) 匹配
print(string.match("hello lua", "lua"))
-->lua
-------------------------------------
--13、string.sub(s, i [, j])
print(string.sub("Hello Lua", 4, 7))
print(string.sub("Hello Lua", 2))
-------------------------------------
--14、string.gsub(s, p, r [, n])
print(string.gsub("Lua Lua Lua", "Lua", "hello"))
-->hello hello hello 3
print(string.match("hello 2019/1/2","%a%a%a%a%a"))
-->hello
table表
Lua Table的索引下标是从 1 开始的 不是 0
创建空的表
local mytable = { }
指定值
mytable[1] = "Hello Lua"
清空操作
mytable = nil
函数操作
table.concat(table,[,sep[,i[,j]]])连接
sep为填充字符，默认为空白，将table[i]到table[j]连城字符串
local mytable = {"hello","lua","ceshi"}
print(table.concat(mytable,"--"))
>>hello--lua--ceshi
table.insert(table,[pos,]value)
table 的pos位置插入value值
local mytable = {"hello","lua","ceshi"}
table.insert(mytable,"sport")
print(table.concat(mytable,"|"))
>>hello|lua|ceshi|sport
table.maxn(table)
获取表内整数key中最大的key值 如果不存在正数 则返回0
自定义函数实现
function table_maxn(t)
local tmp = nil;
for k,v in pairs(t) do
if(tmp==nil) then
tmp = v
end
if tmp < v then
tmp = v
end
end
return tmp
end
tb1 = {[1] = 10,[2] =100,[3] = 60,[26] = 50}
print(table.maxn(tb1))
table.sort(table,[,comp])
对table进行升序排列
local mytable = {[1] = 10, [2] = 100, [3] = 60, [4] =50}
table.sort(mytable)
print("table 排序：", table.concat(mytable,"-"))
>> 10-50-60-100
table.remove(table[,pos])
删除table中pos位置的元素 ，默认值为表的长度即删除最后一个
若删除的是中间位置，则其后的索引值都会减一
local mytable = {"hello","lua","ceshi"}
print(table.remove(mytable,1))
>>hello
模块
多文件调用 模块化编程时 lua的调用其他模块方法
新建splitutil.lua
新建main.lua
local splitutil = require(“splitutil”) --引入splitutil
splitutil.split() --调用splitutil.lua中的function
for 型迭代器
ipairs(t)遍历数值型索引值
table根据内部类型分为数字型table和非数字型(泛型)table
for k,v in ipairs do
doSomething()
end
ipairs()函数是按照连续数值型索引的值，对于非数字型咋不输入
而且只遍历连续数值 若中间间断则无法继续索引
pairs(t)可以遍历混合型的table
local table2 = {[1] = "a",["hello"] = "aaaa",[2] = "b",[4] = "c"}
for i,v in pairs(table2) do
print("i=",i,"v=",v )
end
所有元素输出是无序的
ipairs(t)函数只能是数值型索引table，输出结果为连续数值型索引，若有中断则只输出连续的元素。
pairs(t)函数可以支持纯数值型索引和混合索引table，且无序输出。
元表
setmetable(table,metatable) --对指定的table表设置元表metatable
getmetatable(table) --获取table的元素
local mytable = { }
local mymetatable = { }
setmetable(mytable,mymetatable)
可简写为setmetable({},{})
运算原方法
__add +
__sub -
__mul *
__div /
__mod %
__eq ==
__It <
__le <=
元方法
__index 查找table中索引值key，对table表的访问
__newindex 对table表进行更新
__tostring 输出字符串
__call 调用值
__mode 用于弱表
__metatable 用于保护metatable不被访问
文件I/O操作
操作方法 说明
io.open (filename [, mode]) 按照指定的mode打开一个文件
io.close ([file]) 关闭文件，若无参数，关闭默认输出文件
io.flush () 把缓冲区的数据写入到文件中
io.input ([file]) 打开文件（文本模式）
io.lines ([filename]) 以读的方式返回一个迭代器
io.output ([file]) 类似于 io.input，但操作在默认输出文件上
io.read (…) 相当于io.input():read
io.type (obj) 检查obj是不是文件如果是打开的，则返回file，
若不是则返回"close file"，如果不是文件则返回nil
io.write (…) 相当于io.output():write写文件
file:close () 关闭文件
file:flush () 把缓冲区的数据写入到file中
file:lines () 返回迭代函数，每次调用返回一行数据，文件尾时返回nil，但是不关闭文件
file:read (…) 按照指定格式读取文件，返回字符串或数字，读取错误返回nil，没有设置按照行读取
file:write (…) 写文件，参数必须是字符串或数字
file:seek ([whence] [, offset]) 设置和获取当前文件位置，成功返回文件位置，失败返回nil
file:setvbuf (mode [, size]) 设置文件缓冲模式
io.open模式
r 只读模式(默认) 返回nil和错误信息
w 写模式 创建文件 会将之前有的内容删除掉
a 添加模式 创建文件
r+ 更新模式，保存之前的数据 返回nil和错误信息
w+ 更新模式，清除之前的数据 创建文件
a+ 添加更新模式，保存之前的数据，在文件尾添加 创建文件
io.write 输出文件内容
1.
file = io.open("lua.txt","r")
for line in file:lines() do
print(line)
end
io.close()
2.
for line in io.lines("lua.txt") do
print(line)
end
io.write("") 写入文件内容
file = io.open("lua.txt","a")
io.output(file)
io.write("\n....lua world") --且每执行一次写入一次
io.close(file)
for line in io.lines("lua.txt") do
print(line) --将行打印出来
end
lua面向对象
面向对象特征
封装：把一个实体的信息封装到一个对象中。
继承：在不改变原有程序的基础上进行扩展，有利于减少代码重复提高开发效率。
多态：同一操作作用在不同的对象上，产生不同的结果。
接下来介绍下Lua如何实现面向对象的，在开始前先说下点和冒号的区别：
. 需要接受self参数
: 默认传入self
.的实现方法
local _M = {
username = "zhangsan",
age = 30
}
function _M.getusername(self)
return self.username
end
function _M.getage(self)
return self.age
end
return _M
local sharep = require("sharep")
local username = sharep.getusername(sharep)
print(username)
local age = sharep.getage(sharep)
print(age)
:的实现方式
local _M = {
rate = 3.14,
lang = 1
}
local mt = {__index = _M}
function _M:new()
setmetatable(_M,mt)
return _M
end
function _M.area(lang)
self.lang = lang
local area = self.rate*(lang/2)*(lang/2)
return area
end
return _M
第一次写博客,将今天学习的lua基本语法纪录下来,希望能坚持下去！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
