Lua学习记录 — (5)字符串

最新推荐文章于 2023-03-19 16:56:26 发布
最新推荐文章于 2023-03-19 16:56:26 发布
阅读量375 收藏
点赞数 3
分类专栏： Script（python、Lua、Javascript） 文章标签： lua
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BeiJiaan/article/details/79220737
版权

String.lua

------------------------------------ Lua字符串表示方式 ------------------------------------

-- 单引号
str = 'hello'

-- 双引号
str = "hello"

-- [[]]
str = [[
hello
baby
]]

------------------------------------ 转义字符 ------------------------------------

--[=[
\a响铃   \b退格    \f换页    \n换行    \r回车    \t水平制表符（下一个TAB位置）
\v水平制表符     \\代表一个反斜线字符     \'代表单引号字符   \"代表双引号字符   \0空字符（null）
\ddd十进制数代表的字符（\010表示换行）     \xhh十六进制数表示的字符（\x0a表示换行：Lua5.3）
]=]

------------------------------------ 字符串操作(string库) ------------------------------------

---- byte(s[,i[,j]]) ：获取字符串的内部数字编码
str = "abcde"
print(string.byte(str,2,4))                                               --> 98 99 100

---- char(...) ：将数字编码转化为字符串
print(string.char(97,98,99,100,101))                                        --> abcde
print(string.char(228,189,160,229,165,189))                                 --> 你好

---- dump(function,[,strip]) ：将函数转换成二进制码
function dumpTest()
    print("dump测试")
end
a = string.dump(dumpTest)
print(a)                                                                        --> LuaQ
b = loadstring(a)   -- 加载一段字符串代码，即把字符串转换成代码
print(b)                                                                        --> function: 00ADBED0
print(dumpTest)                                                                 --> function: 00ADBE50（注意：并不是指向同一个函数，因此地址不同）
b()                                                                             --> dump测试

---- fing(s,pattern[,init[,plain]]) ：从目标字符串中搜索指定的内容，并返回位置
-- 不存在则返回nil
numStart,numEnd = string.find("lua python lua python","lua")
print(numStart,numEnd)                                                          --> 1 3
numStart,numEnd = string.find("lua python lua python","lua",3)
print(numStart,numEnd)                                                          --> 12 14

---- fomat(formatstring,...) ：格式化字符串
str = "%d is a number"
num = 100
Fomatstr = string.format(str,num)
print(Fomatstr)                                                                 --> 100 is number
-- q选项：将字符串用双引号括起来
Fomatstr = string.format("%q","100 is a 'number'")
print(Fomatstr)                                                                 --> "100 is 'number'"

---- gsub(s,pattern,repl[,n]) ：获取字符串迭代器
-- 每次调用会继续以pattern对s做匹配，并返回所有捕获到的值；
-- 如果pattern中没有指定捕获，则每次捕获整个pattern；
str = "python lua c cpp csharp"
for word in string.gmatch(str,"%a+")do
    print(word)                                                                 --> python/lua/c/cpp/csharp
end
str = "key1:lua, key2:python, key3:c, key4:cpp"
tbl = {}
for k,v in string.gmatch(str,"(%w+):(%w+)")do
    tbl[k]=v
end
print(string.format("k = %s , v = %s",'key2',tbl.key2))         --> k = key2 , v = python
print(string.format("k = %s , v = %s",'key4',tbl['key4']))      --> k = key4 , v = cpp

---- gsub(s,pattern,repl[,n]) ：将字符串中所有指定的字符子串替换成指定字符串，并返回其副本
-- repl可以是字符串、表、或函数；（返回的数字，为发生替换的次数）
-- 如果repl是字符串，则把这个字符串作为替代品；
str = "lua c c c"
rlt,num = string.gsub(str,"c","lua")    -- 不加n参数，表示全部替换
print(rlt,num)                                                                      --> lua lua lua lua 3
rlt,num = string.gsub(str,"c","python",2) -- n=2，表示只替换前2个
print(rlt,num)                                                                      --> lua python python c 2
--repl中的所有形式为%d的串，表示第d个捕获到的字符子串（d可以是1到9），%0表示整个匹配
rlt = string.gsub("lua python c csharp","(%w+)","%1 %1")
print(rlt)                                                                            --> lua lua python python c c csharp csharp
rlt = string.gsub("lua python c csharp","%w+","%1 %1",1)  -- n=1表示只替换1次
print(rlt)                                                                            --> lua lua python c csharp
rlt = string.gsub("lua python c csharp","(%w+)%s*(%w+)","%2 %1")
print(rlt)                                                                            --> python lua csharp c
rlt = string.gsub("lua python c csharp","(%w+)%s*(%w+)","%0 %2 %1",1)
print(rlt)                                                                            --> lua python python lua c csharp

-- 如果repl是函数，则在每次匹配发生时，都会调用这个函数；所有捕获到的子串一次作为参数传入；
str = "4+5 = $return 4+5$; 8-20 = $return 8-20$;"
rlt = string.gsub(str,"%$(.-)%$",function (s)
    return loadstring(s)()
end)
print(rlt)                                                                            --> 4+5 = 9; 8-20 = -12;

-- 如果repl是表，每次匹配时，都会用第一个捕获物作为键去查这张表；
tbl = {language = "lua",version = "5.1"}
rlt = string.gsub("$language-$version.tar.gz","%$(%w+)",tbl)               --> lua-5.1.tar.gz
print(rlt)

---- 获取字符串长度 len(s)
str = "lua python"
len = string.len(str)
print(len)                                                                            --> 10
print(string.len(""))                                                              --> 0

---- 大写字母转小写字母 lower(s)
str = "LUA PYTHON27"
print(string.lower(str))                                                              --> lua python27

---- 从字符串中找到一个指定的子字符串，并返回 match(s,pattern[,init])
-- 找不到则返回nil
str = "lua  123 python"
print(string.match(str,"%d+ %w+"))                                            --> 123 python

---- 返回字符串的n个拷贝 rep(s,n)
print(string.rep("hello",2))                                                    --> hellohello

---- 翻转字符串 reverse(s)
print(string.reverse("abcde"))                                                     --> edcba

---- 返回某个位置范围内的字符子串 sub(s,i,j)
print(string.sub("abc def ghi jkl",2,6))                                      --> bc def

---- 小写字母转大写字母 upper(s)
print(string.upper("hello"))                                                       --> HELLO


------------------------------------ 字符串格式化 ------------------------------------

-- %c 接收数字，转化为ASCII码对应的字符
print(string.format(" %c",101))                                       --> e
-- %d %i 接收数字，转化为有符号的整数格式
print(string.format("%d %i",33.33,-33.33))                            --> 33 -33
-- %u 接收数字，转化为无符号的整数格式
print(string.format("%u",-33.33))                                     --> 4294967263
-- %e %E 接收数字，转化为科学计数法格式
print(string.format("%e %E",-33.33,-33.33))                           --> -3.333000e+001 -3.333000E+001
-- %f 接收数字，转化为浮点数格式
print(string.format("%f",-33.33))                                     --> -33.330000
-- %g %G 接收一个数字，转化为%e(%E，对应%G)及%f中较短的一种格式
print(string.format("%g",-33.33))                                     --> -33.33
print(string.format("%g %G",-3333333.33,-3333333.33))                 --> -3.33333e+006 -3.33333E+006
-- %s 接收一个字符串
print(string.format("%s",tostring(-3333.3333)))                       --> -3333.3333
-- %o 接收一个数字，转化为八进制格式
print(string.format("%o",20))                                         --> 24
-- %x %X 接收一个数字，转化为十六进制格式
print(string.format("%x %X",30,30))                                   --> 1e 1E

---- 细化格式
-- 符号：加一个＋号，将让正数显示正号
print(string.format("%+f",33.33))                                     --> +33.330000
-- 占位符+宽度数值：（在宽度前加0，则用0占位，否则默认用空格）
print(string.format("%10s","hello"))                                  -->      hello
print(string.format("%010s","hello"))                                 --> 00000hello
print(string.format("%10g",33.3))                                     -->       33.3
print(string.format("%010d",33.3))                                    --> 0000000033
print(string.format("%010f",33.3))                                    --> 033.300000
-- 对齐标识：在指定了占位宽度时，加-号可以改为左对齐
print(string.format("%-10s|","hello"))                                --> hello     |
print(string.format("%-010s|","hello"))                               --> hello     |
print(string.format("%-10g|",33.3))                                   --> 33.3      |
print(string.format("%-010d|",33.3))                                  --> 33        |
print(string.format("%-010f|",33.3))                                  --> 33.300000 |
-- 小数位数/字符串裁切：
print(string.format("%.5s","abcdefghijk"))                            --> abcde
print(string.format("%8.5s","abcdef"))                                -->    abcde
print(string.format("%.5f",33.12345678))                              --> 33.12346
print(string.format("%010.5f",33.33333))                              --> 0033.33333
print(string.format("%10.5g",33.33333))                               -->     33.333

------------------------------------ 字符串匹配模式 ------------------------------------

---- 用于模式匹配函数 string.fing\gmatch\gsub\match（以下注解输出的'/'表示下一行）
str = "abc123ABC\n0 ;"
-- 单个字符x（x不能是魔法字符^$()%.[]*+-?其中之一）
rlt = string.gsub(str,"c","v")
print(rlt)                                                                            --> abv123ABC/0 ;
-- 点.：任何字符
rlt = string.gsub(str,".","v")
print(rlt)                                                                            --> vvvvvvvvvvvvv
-- %a：任何字母（alphabet）
rlt = string.gsub(str,"%a","v")
print(rlt)                                                                            --> vvv123vvv/0 ;
-- %c：任何控制字符（control）
rlt = string.gsub(str,"%c","v")
print(rlt)                                                                            --> abc123ABCv0 ;
-- %d：任何数字（digit）
rlt = string.gsub(str,"%d","v")
print(rlt)                                                                            --> abcvvvABC/v ;
-- %l：小写字母（low）
rlt = string.gsub(str,"%l","v")
print(rlt)                                                                            --> vvv123ABC/0 ;
-- %p：任何标点符号（punctuation）
rlt = string.gsub(str,"%p","v")
print(rlt)                                                                            --> abc123ABC/0 v
-- %s：任何空白字符（space）不只是空格
rlt = string.gsub(str,"%s","v")
print(rlt)                                                                            --> abc123ABCv0v;
-- %u：大写字母（up）
rlt = string.gsub(str,"%u","v")
print(rlt)                                                                            --> abc123vvv/0 ;
-- %w：字母及数字（word）
rlt = string.gsub(str,"%w","v")
print(rlt)                                                                            --> vvvvvvvvv/v ;
-- %x：16进制（这里只有abcdefABCDEF字母属于16进制）
rlt = string.gsub(str,"%x+","v")
print(rlt)                                                                            --> v/v ;（abc123ABC与0都算是16进制）
-- %x：特殊字符x（例如功能字符().%+-*?[]^$）
rlt = string.gsub("().%+-*?[]^$","%%","V")
print(rlt)                                                                            --> ().V+-*?[]^$
rlt = string.gsub("().%+-*?[]^$","%(","V")
print(rlt)                                                                            --> V).%+-*?[]^$
-- [set]集合：所有字符的联合；（使用'-'连接的表示升序范围）
rlt = string.gsub("().%+-*?[]^$","[%.%+%?%$]","V")
print(rlt)                                                                            --> ()V%V-*V[]^V
rlt = string.gsub(str,"[a-d]","V")
print(rlt)                                                                            --> VVV123ABC/0 ;
rlt = string.gsub("hello LUA! i am lua5.1!","[a-d]%l+","V")
print(rlt)                                                                            --> hello LUA! i V lua5.1!（a属于集合[a-d],m属于%l）
rlt = string.gsub("a123 asd 5aa bbaa8 bbtaa8!","[a-d]+%d+","V")
print(rlt)                                                                            --> V asd 5aa V bbtV!
-- [^set]：set的补集
rlt = string.gsub("abCdEFgH,;g","[^%l]","V")
print(rlt)                                                                            --> abVdVVgVVVg

---- 模式条目
-- +：重复1次或多次（匹配尽可能长的串）
rlt = string.gsub("/#abc#/ /##/ /# #/ /#a#/ /#abc#/","/#%l+#/","$")
print(rlt)                                                                            --> $ /##/ /# #/ $ $
-- *：重复0次或多次（匹配尽可能长的串）
rlt = string.gsub("/#abc#/ /##/ /# #/ /#a#/ /#abc#/","/#%l*#/","$")
print(rlt)                                                                            --> $ $ /# #/ $ $
-- -：重复0次或多次（匹配尽可能短的串）
rlt = string.gsub("/#abc#/ /##/ /# #/ /#a#/ /#abc#/","/#.-#/","$")
print(rlt)                                                                            --> $ $ $ $ $
rlt = string.gsub("/#abc#/ /##/ /# #/ /#a#/ /#abc#/","/#.+#/","$")
print(rlt)                                                                            --> $
-- ?：重复0次或1次（匹配尽可能短的串）
rlt = string.gsub("/#abc#/ /##/ /# #/ /#a#/ /#abc#/","/#.?#/","$")
print(rlt)                                                                            --> /#abc#/ $ $ $ /#abc#/

-- %n：n可以是0到9，匹配第n号捕获物；
rlt = string.gsub("$name = abc; $age = 0","(%$%l+) = (%w+)","%2 %1")
print(rlt)                                                                            --> abc $name; 0 $age
rlt = string.gsub("$name = abc; $age = 0","(%$%l+ = %w+).+(%$%l+ = %w+)","%2 ; %1")
print(rlt)                                                                            --> $age = 0 ; $name = abc

-- %bxy：从x开始到y结束的保持平衡的字符串；
rlt = string.gsub("f(x) = ((a+b)*5 - c)/d","%b()","$")
print(rlt)                                                                            --> f$ = $/d

---- 模式：
-- 指一个模式条目的序列；
-- 在模式最前面添加^，将锚定从字符串的开始处做匹配；
-- 在模式最后面添加$，将锚定从字符串的结束处做匹配；

---- 捕获：
-- 模式可以在内部用小括号括起一个子模式，这些子模式被称为 捕获物；
-- 以左括号的出现顺序来确定次序编号；如 (a*(.)%w(%s))，顺序分别是：1号 a*(.)%w(%s)  2号 .   3号 %s

------------------------------------ 字符串运算符 ------------------------------------

---- 字符串连接符号：..
print("abc" .. "123")                                                             --> abc123

---- 字符串长度获取符号：#（其实也可以用于list）
print(#"asd123")                                                                  --> 6

---- 数字字符串的运算(算数运算符基本都可以使用)
print("12"+"13")                                                                  --> 25
print("12"+13)                                                                    --> 25
print("12"%"5")                                                                   --> 2

--[=[       《补充》
字符串库在初始化的时候，为字符串类型设置了元表；
]=]

str = "abcdefg"
print(str:len())                                                                     --> 7
str = "%g is a numbers!"
print(str:format(55.55))                                                             --> 55.55 is a numbers!
BeiJiaan
关注
专栏目录
【lua学习】3.字符串
qq_18138105的博客
03-06 862
【lua学习】3.字符串Lua字符串的概况字符串实现字符串结构TString全局字符串表stringtable新建字符串luaS_newlstr （先查表，再决定创建与否）新建字符串 newlstr重新设置全局字符串的大小 luaS_resize全局字符串表的缩容保留字是如何不被回收的 Lua字符串的概况 Lua虚拟机中存在一个散列桶结构的全局字符串表来存放所有字符串 关于比较字符串：先比较hash，再比较长度，再逐字符比较。节省时间 同一个字符串在Lua虚拟机中仅有一个副本。节省空间 一旦创建则无法变更
【Lua学习笔记】Lua字符串及string函数
行识
04-14 912
Lua的string函数也是我在日常工作中使用最多的，但是都是比较简单的~上周末看的视频讲的也比较浅显。整理一下笔记，不然我下次又忘记咋用了。。 字符串的表示 --字符串可以用""或者用''来表示 --For example local str1 = "Lua" local str2 = 'Lua' 转义字符串 --常用的转义字符串：/r(回车)、/n(换行)、/r/n(回车换行)...
Lua中的常用字符串处理方法：
ls_sir的博客
04-21 921
1，计算长度: #str 2，String.byte:返回字符的ASCII码 3，String.char:返回和参数数量相同长度的字符串，其中每个字符的内部编码值等于对应的参数、 4，String.upper 将字符转换为大写字符 5，String.lower 将字符转换成小写字符 6，String.gsub 将字符串中的a用g替换，循环替换2次 7,string.sub ...
Delphi Byte[] 转String 中文乱码问题解决
suixinwuyu的专栏
03-29 4839
Socket通信时，取中文时乱码，这主要是编码问题AnisString是双字节编码，而Unicode是3字节编码解决办法const buf:array[0..8] of byte =(228, 189, 160, 229, 165, 189, 239, 188, 129); //buf:TByteArray; 这两个效果一样var  s: string;  i:Integer;  stream: ...
谈谈java中字节byte有负数的现象
默默前行，勿喜、勿悲、一切随缘！
01-19 3万+
在研究编码时，无意中发现java中输出编码后的字节数据的值有的是负值，比如utf-8编码后的字节数据，通过遍历，打印都是负值，java中字节byte有负数的现象让我产生了兴趣，在此探讨一下。 关于编码的字节有负数的现象，可以参考这篇博客： http://blog.csdn.net/csdn_ds/article/details/79077483 下面我用java中的数据流去说说这个现象。
Lua字符串操作
至虛極，守靜篤
03-30 3481
Lua的字符串操作。
Lua 字符串处理
qq_39218906的博客
07-19 943
今天项目中遇到一个字符串处理的通用函数，一事不明白胡乱搜索后才发现原来是字符串处理库里面的通用函数，想着该理一遍字符串。 这个库提供了字符串处理的通用函数。例如字符串查找，子串，模式匹配等。当在Lua中对字符串做索引时，第一个字符从1开始计算（而不是C里的0）。索引可以是负数。它指从字符串末尾反向解析。即，最后一个字符在-1位置处，等等。 字符串库中的所有函数都在表string中，它还将其设置...
Lua学习笔记-字符串操作
最新发布
天才三井的博客
03-19 330
Lua字符串操作
lua基础学习笔记-字符串
lovemo的博客
07-03 1135
lua基础学习笔记—字符串 字符串 Lua 语言中字符串可以使用以下三种方式来表示： 单引号间的一串字符。 双引号间的一串字符。 [[ 与 ]] 间的一串字符。 例： string1 = "Lua1" print("\"字符串1是\"",string1) string2 = 'Lua2' print("字符串2是",string2) string3 = [[ "Lua 3" "Lua333" Lua333333 ]] print("字符串3是\n",string3) 结果：中文乱码问题请忽略 E:\d
Lua学习笔记之表达式
09-22
【Lua学习笔记之表达式】 在Lua编程语言中，表达式是构成程序的基本元素，用于表示计算或逻辑操作。表达式的结果可以是一个值，也可以是一个布尔值，这取决于执行的操作。下面我们将深入探讨Lua中的各种表达式类型...
lua脚本之字符串与浮点型数据的转换
java100001的博客
05-09 1956
table.sort(a, function (a, b) return string.lower(a) < string.lower(b) end) string.upper(s) 将s中的小写字母转换成大写 string.upper和string.lower都依赖于本地环境变量。所以，如果你在 European Latin-1环境下，表达式： string.upper(“a??o”) --> “A??O” `` string.sub(s,i,j) 函数截取字符串s的从第i个字
mysql 5.5版本 安装与卸载
zimushuang的博客
03-27 1万+
MySQL5.5安装教程转载：https://www.cnblogs.com/solargen/p/6835399.html         https://jingyan.baidu.com/article/f96699bbaa8fc1894f3c1b5a.html1、 官网下载mysql5.5下载地址：http://dev.mysql.com/downloads/mysql/5.5.html#...
lua字符串处理(string库用法)
热门推荐
戴磊的博客
05-10 7万+
原文地址http://www.daileinote.com/computer/lua/02 lua的string库是用来处理字符串的，基础函数如下 string.byte(s [, i [, j]]) string.byte是用来把字符转换成ascii数字，s为目标字符串，i为索引开始位置(从1开始)，j为索引结束位置 string.char(...) string.char是把as...
Lua string.gsub 模式匹配
qq_24671901的博客
06-02 7947
    网上找了一些关于gsub模式匹配资料，但是都不全面细致，所以打算翻译官方文档。以下内容翻译自《Lua 5.3 Reference Manual》6.4.1 - Patterns。 ------ 我是一个分割线------    Lua中的模式匹配用正则表达式来描述，它被用于string.find, string.gmatch,string.gsub, 和 string.match.匹配一种...
Lua学习记录 — (7)列表、元组
BeiJiaan的博客
02-01 3414
– 最近修改： 2018/2/3 TableMetatable.lua ------------------------------------ 表Table ------------------------------------ ---- 数组 -- 一维数组 array = {1,2,'a','b'} for i,v in ipairs(array) do print(v)
Lua学习记录 — (10)面向对象-类（公有私有属性/静态，重写，运算符重载，继承等等）
BeiJiaan的博客
02-04 1671
BjaClass类模拟包——点击下载 ObjectOriented.lua ------------------------------------ Lua面向对象 ------------------------------------ -- Lua中没有直接的类定义方法；（需要通过模拟来实现） ----- 类的封装 -- Lua中的类可以通过 table 来模拟实现； do
Lua5.3.4 源码编译（win10、vs2015）
BeiJiaan的博客
02-07 928
ide：vs2015 system：win10 source：lua5.3.4 generous：lua.exe（解释器）、luac.exe（编译器）、 　　　　　　lua.lib（静态库）、luad.dll luad.lib（动态库） 最终结果 静态库 创建工程Lua53与项目Lua53-lib（自动生成的任何文件都删掉） 在工程根目
Lua学习记录 — (3)条件语句与循环语句
BeiJiaan的博客
01-31 708
ConditionalAndLoopStatement.lua ------------------------------------ Lua条件语句 ------------------------------------ a,b,c = 0,1,nil -- if 语句 if (a and b) then print(a and b)
Lua编程入门：学习之旅
这意味着你可以用同一个变量存储不同类型的值，如数字、字符串、布尔值、表（数组/哈希混合结构）、函数等。 2. **表（Tables）**：表是Lua中的核心数据结构，可以用来实现数组、集合、记录（structs）甚至对象。表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值