lua string 函数的一些理解

string库提供了字符串处理的通用函数。 例如字符串查找、子串、模式匹配等。 当在 Lua 中对字符串做索引时，第一个字符从 1 开始计算（而不是 C 里的 0 ）。 索引可以是负数，它指从字符串末尾反向解析。 即，最后一个字符在 -1 位置处，等等。

字符串库中的所有函数都在表string 中。 它还将其设置为字符串元表的__index 域。 因此，你可以以面向对象的形式使用字符串函数。 例如，string.byte(s,i) 可以写成 s:byte(i)。

—@param s string

—@param optional i number

-–@param optional j number

function string.byte(s, i, j) end

返回字符串s[i]. s[i+1],…,s[j]的内部数字编码。i的默认值是1，j的默认值是i

注意的是该函数在返回的数字编码在跨平台方面不一定是可移植的。

s = 'abc'
print(string.byte(s))
print(string.byte(s,2))
print(string.byte(s,2,3))

输出:
97
98
98  99

—@return string

function string.char(…) end

接收零或更多的整数。 返回和参数数量相同长度的字符串。 其中每个字符的内部编码值等于对应的参数值。

print(string.char(98, 99, 100))

输出:
bcd

—@param func fun()

function string.dump(func) end

返回包含有以二进制方式表示的（一个 二进制代码块 ）指定函数的字符串。 之后可以用 loadstring 调用这个字符串获得 该函数的副本。

function必须是没有upvalues的lua函数。

function dump()
print("dump test  ")
end

s = string.dump(dump)
print(s)

func = loadstring(s)
func()

输出:
dump test

—@param s string

—@param pattern string

—@param optional init number

—@param optional plain boolean

—@return number, number

function string.find(s, pattern, init, plain) end

查找字符串 s 中第一个匹配到的 pattern 如果找到一个匹配，find 会返回 s 中关于它起始及终点位置的索引； 否则，返回 nil。 第三个可选数字参数 init 指明从哪里开始搜索； 默认值为 1 ，同时可以是负值。 第四个可选参数 plain 为 true 时， 关闭模式匹配机制。 此时函数仅做直接的 “查找子串”的操作， 而 pattern 中没有字符被看作魔法字符。 注意，如果给定了 plain　，就必须写上 init。

如果在模式中定义了捕获，捕获到的若干值也会在两个索引之后返回。

local s = "abcdefg"
print(string.find(s,"(c)"))
print(string.find(s,"(c)"),1, true)

输出:
3   3   c
3   1   true

—@param formatstring string

—@return string

function string.format(formatstring, …) end

第一个参数为字符串格式，后面的参数可以任意多个，用于填充第一个参数中的格式控制符，最后返回完整的格式化后的字符串。

格式控制符以%开头，常用的有以下几种

* %c - 接受一个数字,并将其转化为ASCII码表中对应的字符

* %d, %i - 接受一个数字并将其转化为有符号的整数格式

* %o - 接受一个数字并将其转化为八进制数格式

* %u - 接受一个数字并将其转化为无符号整数格式

* %x - 接受一个数字并将其转化为十六进制数格式,使用小写字母

* %X - 接受一个数字并将其转化为十六进制数格式,使用大写字母

* %e - 接受一个数字并将其转化为科学记数法格式,使用小写字母e

* %E - 接受一个数字并将其转化为科学记数法格式,使用大写字母E

* %f - 接受一个数字并将其转化为浮点数格式

* %g(%G) - 接受一个数字并将其转化为%e(%E,对应%G)及%f中较短的一种格式

* %q - 接受一个字符串并将其转化为可安全被Lua编译器读入的格式

* %s - 接受一个字符串并按照给定的参数格式化该字符串

示例：

string.format("%%c: %c", 83)            输出S
string.format("%+d", 17.0)              输出+17
string.format("%05d", 17)               输出00017
string.format("%o", 17)                 输出21
string.format("%u", 3.14)               输出3
string.format("%x", 13)                 输出d
string.format("%X", 13)                 输出D
string.format("%e", 1000)               输出1.000000e+03
string.format("%E", 1000)               输出1.000000E+03
string.format("%6.3f", 13)              输出13.000
string.format("%s", "monkey")           输出monkey
string.format("%10s", "monkey")         输出    monkey
string.format("%5.3s", "monkey")        输出  mon

—@param s string

—@param pattern string

function string.gmatch(s, pattern) end

s = "hello world from Lua"
for w in string.gmatch(s, "%a+") do
print(w)
end

输出:
hello
world
from
Lua

—@param s string

—@param pattern string

—@param repl table|fun()

—@param optional n number

function string.gsub(s, pattern, repl, n) end

将字符串 s 中，所有的（或是在 n 给出时的前 n 个） pattern 都替换成 repl ，并返回其副本。 repl 可以是字符串、表、或函数。 gsub 还会在第二个返回值返回一共发生了多少次匹配。 gsub 这个名字来源于 Global SUBstitution 。

如果 repl 是一个字符串，那么把这个字符串作为替换品。 字符 % 是一个转义符： repl 中的所有形式为 %d 的串表示 第 d 个捕获到的子串，d 可以是 1 到 9 。 串 %0 表示整个匹配。 串 %% 表示单个 %。

如果 repl 是张表，每次匹配时都会用第一个捕获物作为键去查这张表。

如果 repl 是个函数，则在每次匹配发生时都会调用这个函数。 所有捕获到的子串依次作为参数传入。

任何情况下，模板中没有设定捕获都看成是捕获整个模板。

如果表的查询结果或函数的返回结果是一个字符串或是个数字， 都将其作为替换用串； 而在返回 false 或 nil　时不作替换 （即保留匹配前的原始串）。

-- 匹配字符转
-- 先匹配hello, %1 为匹配值,  将hello 替换为hello hello
-- 匹配world时 同理
print(string.gsub("hello world", "(%w+)", "%1 %1"))
print(string.gsub("hello world", "(%w+)", "%0 %0",1))

输出:
hello hello world world 2
hello hello world   1

-- 替换函数
print(string.gsub("4+5 = $return 4+5$", "%$(.-)%$",
function (s)
print(s)
return loadstring(s)()
end))

输出:
return 4+5
4+5 = 9 1

--表
local t = {name="lua", version="5.3"}
print(string.gsub("$name-$version.tar.gz", "%$(%w+)", t))

输出:
lua-5.3.tar.gz  2

—@param s string

—@return number

function string.len(s) end

接收一个字符串，返回其长度。 空串 “” 的长度为 0 。 内嵌零也统计在内，因此 “a\000bc\000” 的长度为 5 。

print(string.len("hello world \0"))

输出:
13

—@param s string

—@return string

function string.lower(s) end

接收一个字符串，将其中的大写字符都转为小写后返回其副本。 其它的字符串不会更改。 对大写字符的定义取决于当前的区域设置。

print(string.lower("HeLLo World"))

输出:
hello world

—@param s string

—@param pattern string

—@param optional init number

function string.match(s, pattern, init) end

在字符串 s 中找到第一个能用 pattern匹配到的部分。 如果能找到，match 返回其中的捕获物； 否则返回 nil 。 如果 pattern 中未指定捕获， 返回整个 pattern 捕获到的串。 第三个可选数字参数 init 指明从哪里开始搜索； 它默认为 1 且可以是负数。

print(string.match("hello world", "(%w+)"))
print(string.match("hello world", "(%w+)", -1))

输出:
hello
d

d7e7
—@param s string

—@param n number

—@return string

function string.rep(s, n) end

返回n个字符串s连在一起的字符串

print(string.rep("abc", 2))

输出:
abcabc

—@param s string

—@return string

function string.reverse(s) end

返回字符串 s 的翻转串。

print(string.reverse("abc"))

输出:
cba

—@param s string

—@param i number

—@param j number

—@return string

function string.sub(s, i, j) end

返回 s 的子串， 该子串从 i 开始到 j 为止； i 和 j 都可以为负数。 如果不给出 j ，就当它是 -1 （和字符串长度相同）。 特别是， 调用 string.sub(s,1,j) 可以返回 s 的长度为 j 的前缀串， 而 string.sub(s, -i) 返回长度为 i的后缀串。

print(string.sub("Hello World", 5))
print(string.sub("Hello World", -3))

输出:
o World
rld

—@param s string

—@return string

function string.upper(s) return “” end

接收一个字符串，将其中的小写字符都转为大写后返回其副本。 其它的字符串不会更改。 对小写字符的定义取决于当前的区域设置。

print(string.upper("Hello World"))

输出:
HELLO WORLD

lua正则表达式

魔法字符 ^$()%.[]+-? 中的一员



示例

截取字符

local s = "hello world (哈哈)"
local i,j= string.find(s,"%(.*%)")
local name = string.sub(s, i,j)
print(name)     --(哈哈)

计算字符串长度

local s = "同时获得纳兹(传奇)、格雷(传奇)将会hah"
local lenInByte = #s
local width = 0
local i = 1
while (i<=lenInByte) do
local curByte = string.byte(s, i)
local byteCount = 1;
if curByte>0 and curByte<=127 then
byteCount = 1                                               --1字节字符
elseif curByte>=192 and curByte<223 then
byteCount = 2                                               --双字节字符
elseif curByte>=224 and curByte<239 then
byteCount = 3                                               --汉字
elseif curByte>=240 and curByte<=247 then
byteCount = 4                                               --4字节字符
end

local char = string.sub(s, i, i+byteCount-1)
print(char)                                                          --看看这个字是什么
i = i + byteCount                                              -- 重置下一字节的索引
width = width + 1                                            -- 字符的个数（长度）
end
print(width)

byte转string

--网上说一次最大只能处理10k的数据，也就是长度为10000个字节的数据,所以进行分块处理
local function BytesToString( bytes )
if nil == bytes then
return nil
end
if ( table.getn( bytes ) <= 7000 ) then
return string.char(unpack(bytes))
end
local toReturn = ''
local start = 1
local n = 7000

while ( true ) do
toReturn = toReturn .. string.char(unpack(bytes,start,n))
start = n + 1
n = n + 7000
if ( n >= table.getn( bytes ) ) then
toReturn = toReturn .. string.char(unpack(bytes,start,table.getn( bytes )))
return toReturn
end
end
end

--unpack 依次返回table的所有元素
-- Returns the elements from the given table. This function is equivalent to
-- return list[i], list[i+1], ..., list[j]
--使用unpack()
--local a = { 100, 200, 300, 400 }
--print( unpack(a) )
--代替方法
--local a = { 100, 200, 300, 400 }
--print( a[1],a[2],a[3],a[4] )

参考链接：

1、Lua string库整理

2、lua正则表达式

3、在Lua中计算含中文的字符串的长度