两大特点：

1. string库中所有的字符索引从前往后是1,2,...;从后往前是-1,-2,...

2. string库中所有的function都不会直接操作字符串，而是返回一个新的字符串。

库函数：

1、string.len，string.rep，string.upper，string.lower，string.sub，string.format

local str = "abc"

print(string.len(str)) --6

print(string.rep(str, 2^2)) --abcabcabcabc

print(string.upper(str)) --ABC

print(string.lower("ABC")) --abc

print(string.format("%02d/%02d/%04d", 5, 12, 2001))--05/12/2001

print(string.sub(str, 1, 2))--ab

截取字符串str的从第i个字符到第j个字符之间的串。

lua中，字符串的第一个字符索引从1开始,你也可以使用负值,不提供第三个参数,则默认为-1，

2、string.char，string.byte

　　string.byte (s [, i [, j] ]）函数返回字符s[i], s[i+1], ···, s[j]的内部数字编码(ASCII码)，其

      中参数i的默认值是1，而参数j的默认值是i。需要注意的是该函数在返回的数字编码在跨平台方面不一定是可移植的。

local i=97

print(string.char(i))--a

print(string.char(i, i+1, i+2))--abc

print(string.byte("abc"))--97

print(string.byte("abc", 2))--98

print(string.byte("abc", -1))--99

print(string.byte('abc', 1, 3))--97 98 99

string.char函数和string.byte函数用来处理字符和数字之间转换。

string.char获取0个或多个整数，将每一个数字转换成字符，然后返回一个所有这些字符连接起来的字符串。

string.byte(s,i)将字符串s的第i个字符的转换成整数,第二个参数可选，默认为1。

3、string.find, string.match

在目标串内搜索匹配指定的模式串。如果找到则返回对应的位置，否则返回nil。

local str = "hello world"

local i, j = string.find(str, "hello")

print(i, j) -- 1      5

print(string.find(str, "lll"))--nil

 　　string.find( )的第三个参数是可选的：标示目标串中搜索的起始位置。

查找目标串中某单次出现的次数：

local str = "hello Maria! hello Mical! hello Sam!"

local sum = 0

local idx = 0

repeat

      idx = string.find(str, "hello", idx+1)

      if idx then

             sum = sum + 1

      end

until idx == nil

print("sum: ", sum) -- 3

--string.match和string.find类似，都是在指定的string中查找相应的模式。不同的是，他返回的是找到的那部分string

4、string.gsub

函数有四个参数：目标串，模式串，替换串，（可选：最多替换的个数）

返回替换后的字符串和替换的次数。

local str1 = "hello Maria! hello Mical! hello Sam!"

local str2, times1 = string.gsub(str1, "hello", "hi")

print( str2, times1) --hi Maria! hi Mical! hi Sam!3

local str3, times2 = string.gsub(str1, "hello", "hi", 2)

print( str3, times2) --hi Maria! hi Mical! hello Sam!2

string.gsub(s, pattern, func)

local strr = string.gsub(str1, "hello", function(s)

      return s.."_"

end)

print(strr)--hello_ Maria! hello_ Mical! hello_ Sam!

5、string.gfind(s, pattern)

返回一个迭代器，迭代器每执行一次，返回下一个匹配串；

iter = string.gfind("a=b c=d", "[^%s+]=[^%s+]")

print(iter()) -- a=b

print(iter()) -- c=d

通常用于泛性for循环,下面的例子结果同上

for s in string.gfind("a=b c=d", "[^%s+]=[^%s+]") do

      print(s) -- a=b c=d

end

 6、string.dump (function [, strip])

　　返回包含有以二进制方式表示的（一个 二进制代码块 ）指定函数的字符串。

function log(value)
    print(value)
end

local str_fun = string.dump(log)

print(str_fun) --<-LoaQ

local fun = loadstring(str_fun)

fun("hello")

模式：

对lua而言，模式串就是普通的字符串，并不受特殊对待。

1、字符类

.            任意字符

%a        字母

%c         控制字符

%d        数字

%l         小写字母

%p        标点字符

%s         空白符

%u        大写字母

%w       字符和数字

%z         代表0的字符

上面字符类的大写形式表示小写所代表的集合的补集。例如，'%A'表示非字母的字符。print(string.gsub("hello world", "%A", "_")) --hello_world 1

2、特殊字符

(     )      .      %    +     -      *     ?     [      ^     $

'%'用作特殊字符的转义字符，'%.'匹配点；'%%'匹配字符'%'。转义字符'%'不仅可以用来转义特殊字符，还可以用于所有的非字母的字符。当对一个字符有疑问的时候，为安全起见请使用转义字符转义它。

用'[]'创建字符集：（可以使用连字符'-'，在'[]'开始出使用'^'表示补集）

      '[%w_]'  匹配数字字母和下划线，

      '[01]'      匹配二进制数字，

      '[%[%]]'  匹配方括号。

      '[0-9]'     匹配0到9之间的数

      '[^0-7]'   匹配不是0到7之间的字符

3、模式修饰符

+ 匹配前一字符1次或多次，最长匹配

* 匹配前一字符0次或多次，最长匹配

- 匹配前一字符0次或多次，最短匹配

? 匹配前一字符0次或1次

'+'匹配一个或多个字符，总是进行最长匹配。

print(string.gsub("hello Sam.", "%a+", "***")) --*** ***.2

'*'与'+'类似，但是它匹配一个字符0次或多次出现。

 '-'与'*'一样，都匹配一个字符的0次或多次出现，但是它进行的是最短匹配。

print(string.gsub("(hello)world)", "%(.*%)", "*")) --*1

print(string.gsub("(hello)world)", "%(.-%)", "*")) --*world)1

以'^'开头的模式只匹配目标串的开始部分，以'$'结尾的模式只匹配目标串的结尾部分。

print(string.gsub("(hello)(world)", "%(.-%)", "*")) --**2

print(string.gsub("(hello)(world)", "^%(.-%)", "*")) --*(world)1

print(string.gsub("(hello)(world)", "%(.-%)$", "*")) --*1

'%b'用来匹配对称的字符。常写为'%bxy'，x和y是任意两个不同的字符；x作为匹配的开始，y作为匹配的结束。

'%b()'    匹配以'('开始，以')'结束的字符串。

'%b[]'    '%b<>'

function string.split(input, delimiter)
    input = tostring(input)
    delimiter = tostring(delimiter)
    if (delimiter=='') then return false end
    local pos,arr = 0, {}
    -- for each divider found
    for st,sp in function() return string.find(input, delimiter, pos, true) end do
        table.insert(arr, string.sub(input, pos, st - 1))
        pos = sp + 1
    end
    table.insert(arr, string.sub(input, pos))
    return arr
end

--[[

UTF-8

0000 - 007F

0XXXX XXXX

0080 - 07FF

110XXXXX  10XXXXXX

0800 - FFFF

1110XXXX  10XXXXXX 10XXXXXX

]]