[Lua]字符串及字符串匹配

--lua中字符串索引从前往后是1,2,……,从后往前是-1,-2……。

--string库中所有的function都不会直接操作字符串,只返回一个结果 

基本函数

函数

描述

示例

结果

len

计算字符串长度

string.len("abcd")

4

rep

返回字符串s的n个拷贝(repeat重复)

string.rep("abcd",2)

abcdabcd

lower

返回字符串全部字母大写

string.lower("AbcD")

abcd

upper

返回字符串全部字母小写

string.upper("AbcD")

ABCD

format

返回一个类似printf的格式化字符串

string.format("the value is:%d",4)

the value is:4

sub

返回子字符串substring from index i to j of s

string.sub("abcd",2)

bcd

string.sub("abcd",-2)

cd

string.sub("abcd",2,-2)

bc

string.sub("abcd",2,3)

bc

find

在字符串中查找,找到则返回匹配串开始索引和结束索引,否则返回nil。第三个参数是可选的:标示目标串中搜索的起始位置。 

string.find("cdcdcdcd","ab")

nil

string.find("cdcdcdcd","cd")

1 2

string.find("cdcdcdcd","cd",7)

7 8

gsub

全局字符串替换

在字符串中替换(substitution替换),有三个参数:目标串,模式串,替换串。第四个参数是可选的,用来限制替换的范围

string.gsub("abcdabcd","a","z");

zbcdzbcd 2

string.gsub("aaaa","a","z",3);

zzza 3

byte

返回字符的整数形式,字符->数字

string.byte("ABCD",4)

68

char

将整型数字转成字符并连接,数字->字符

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

abcd

 基本模式串

正则表达式

字符类

描述

示例

结果

.

任意字符

string.find("",".")

nil

%s

空白符(space)

string.find("ab  cd","%s%s")

3 4

%S

非空白符

string.find("ab cd","%S%S")

1 2

%p

标点字符(punctuation)

string.find("ab,.cd","%p%p")

3 4

%P

非标点字符

string.find("ab,.cd","%P%P")

1 2

%c

控制字符(control)

string.find("abcd\t\n","%c%c")

5 6

%C

非控制字符

string.find("\t\nabcd","%C%C")

3 4

%d

数字(digit)

string.find("abcd12","%d%d")

5 6

%D

非数字

string.find("12abcd","%D%D")

3 4

%x

十六进制数字(hexadecimal)

string.find("efgh","%x%x")

1 2

%X

非十六进制数字

string.find("efgh","%X%X")

3 4

%a

字母(alpha)

string.find("AB12","%a%a")

1 2

%A

非字母

string.find("AB12","%A%A")

3 4

%l

小写字母(lowercase)

string.find("ABab","%l%l")

3 4

%L

大写字母

string.find("ABab","%L%L")

1 2

%u

大写字母(uppercase)

string.find("ABab","%u%u")

1 2

%U

非大写字母

string.find("ABab","%U%U")

3 4

%w

字母和数字

string.find("a1()","%w%w")

1 2

%W

非字母非数字

string.find("a1()","%W%W")

3 4

转义字符%

字符类

描述

示例

结果

%

转义字符

string.find("abc%..","%%")

4 4

string.find("abc..d","%.%.")

4 5

用[]创建字符集,"-"为连字符,"^"表示字符集的补集

字符类

描述

示例

结果

[01]

匹配二进制数

string.find("32123","[01]")

3 3

[AB][CD]

匹配AC、AD、BC、BD

string.find("ABCDEF","[AB][CD]")

2 3

[[]]

匹配一对方括号[]

string.find("ABC[]D","[[]]")

4 5

[1-3]

匹配数字1-3

string.find("312","[1-3][1-3][1-3]")

1 3

[b-d]

匹配字母b-d

string.find("dbc","[b-d][b-d][b-d]")

1 3

[^%s]

匹配任意非空字符

string.find(" a ","[^%s]")

3 3

[^%d]

匹配任意非数字字符

string.find("123a","[^%d]")

4 4

[^%a]

匹配任意非字母字符

string.find("abc1","[^%a]")

4 4

用"()"进行捕获

字符类

描述

示例

结果

()

捕获字符串

string.find("12ab","(%a%a)")

3 4 ab

string.find("ab12","(%d%d)")

3 4 12

捕获是这样一种机制可以使用模式串的一部分匹配目标串的一部分。将你想捕获的模式用圆括号括起来,就指定了一个捕获。
print(string.find("name = Anna", "(%a+)%s*=%s*(%a+)"))--1 11  name  Anna,匹配并捕获结果
print(string.find("name = Anna", "%a+%s*=%s*%a+"))--1 11,只匹配不捕获结果

'%a+' 表示菲空的字母序列;'%s*' 表示0个或多个空白。

在上面的例子中,整个模式代表:一个字母序列,后面是任意多个空白,然后是 '=' 再后面是任意多个空白,然后是一个字母序列。两个字母序列都是使用圆括号括起来的子模式,当他们被匹配的时候,他们就会被捕获。当匹配发生的时候,find函数总是先返回匹配串的索引下标,然后返回子模式匹配的捕获部分。

模式修饰符

模式修饰符总是必须放在被修饰的后面。如要匹配1个多个数字---print(string.find("[17/1/2015]", "%d+"))--2 3

修饰符

描述

示例

结果

+

表示1个或多个,匹配最多个

string.find("aaabbb","(a+b)")

1 4 aaab

string.find("cccbbb","(a+b)")

nil

-

表示0个或多个,匹配最少个

string.find("zzxyyy","(xy-)")

3 3 x

string.find("zzzyyy","(x-y)")

4 4 y

*

表示0个或多个,匹配最多个

string.find("mmmnnn","(m*n)")

1 4 mmmb

string.find("lllnnn","(m*n)")

4 4 n

?

表示0个或1个

string.find("aaabbb","(a?b)")

3 4 ab

string.find("cccbbb","(a?b)")

4 4 b

应用实例

local number = {}

--给数字添加上千分号
function number.commaSeperate(num)
  local formatted,k = tostring(tonumber(num)),0
  while true do  
    --匹配以[0,1]个减号,[1,n]个数字为开头,紧挨着3个数字,然后再模式1和模式2之间添加上逗号
    formatted, k = string.gsub(formatted,"^(-?%d+)(%d%d%d)",'%1,%2') 
    if k == 0 then break end
  end  
  return formatted
end
local str = number.commaSeperate("-456852963")
print(str)---456,852,963

function string.ltrim(str)
    return string.gsub(str, "^[ \t\n\r]+", "")
end

function string.rtrim(str)
    return string.gsub(str, "[ \t\n\r]+$", "")
end

function string.trim(str)
    str = string.gsub(str, "^[ \t\n\r]+", "")
    return string.gsub(str, "[ \t\n\r]+$", "")
end

String库扩展

--------------------------------
-- @module string


string._htmlspecialchars_set = {}
string._htmlspecialchars_set["&"] = "&"
string._htmlspecialchars_set["\""] = """
string._htmlspecialchars_set["'"] = "'"
string._htmlspecialchars_set["<"] = "<"
string._htmlspecialchars_set[">"] = ">"

-- start --

--------------------------------
-- 将特殊字符转为 HTML 转义符
-- @function [parent=#string] htmlspecialchars
-- @param string input 输入字符串
-- @return string#string  转换结果

--[[--

将特殊字符转为 HTML 转义符

~~~ lua

print(string.htmlspecialchars("<ABC>"))
-- 输出 <ABC>

~~~

]]

-- end --

function string.htmlspecialchars(input)
    for k, v in pairs(string._htmlspecialchars_set) do
        input = string.gsub(input, k, v)
    end
    return input
end

-- start --

--------------------------------
-- 将 HTML 转义符还原为特殊字符,功能与 string.htmlspecialchars() 正好相反
-- @function [parent=#string] restorehtmlspecialchars
-- @param string input 输入字符串
-- @return string#string  转换结果

--[[--

将 HTML 转义符还原为特殊字符,功能与 string.htmlspecialchars() 正好相反

~~~ lua

print(string.restorehtmlspecialchars("<ABC>"))
-- 输出 <ABC>

~~~

]]

-- end --

function string.restorehtmlspecialchars(input)
    for k, v in pairs(string._htmlspecialchars_set) do
        input = string.gsub(input, v, k)
    end
    return input
end

-- start --

--------------------------------
-- 将字符串中的 \n 换行符转换为 HTML 标记
-- @function [parent=#string] nl2br
-- @param string input 输入字符串
-- @return string#string  转换结果

--[[--

将字符串中的 \n 换行符转换为 HTML 标记

~~~ lua

print(string.nl2br("Hello\nWorld"))
-- 输出
-- Hello<br />World

~~~

]]

-- end --

function string.nl2br(input)
    return string.gsub(input, "\n", "<br />")
end

-- start --

--------------------------------
-- 将字符串中的特殊字符和 \n 换行符转换为 HTML 转移符和标记
-- @function [parent=#string] text2html
-- @param string input 输入字符串
-- @return string#string  转换结果

--[[--

将字符串中的特殊字符和 \n 换行符转换为 HTML 转移符和标记

~~~ lua

print(string.text2html("<Hello>\nWorld"))
-- 输出
-- <Hello><br />World

~~~

]]

-- end --

function string.text2html(input)
    input = string.gsub(input, "\t", "    ")
    input = string.htmlspecialchars(input)
    input = string.gsub(input, " ", " ")
    input = string.nl2br(input)
    return input
end

-- start --

--------------------------------
-- 用指定字符或字符串分割输入字符串,返回包含分割结果的数组
-- @function [parent=#string] split
-- @param string input 输入字符串
-- @param string delimiter 分割标记字符或字符串
-- @return array#array  包含分割结果的数组

--[[--

用指定字符或字符串分割输入字符串,返回包含分割结果的数组

~~~ lua

local input = "Hello,World"
local res = string.split(input, ",")
-- res = {"Hello", "World"}

local input = "Hello-+-World-+-Quick"
local res = string.split(input, "-+-")
-- res = {"Hello", "World", "Quick"}

~~~

]]

-- end --

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

function string.split2(s, sep)
  local t = {}
  for o in string.gmatch(s, "([^" .. (sep or " ") .. "]+)") do 
    table.insert(t, o) 
  end
  
  return t
end


-- start --

--------------------------------
-- 去除输入字符串头部的空白字符,返回结果
-- @function [parent=#string] ltrim
-- @param string input 输入字符串
-- @return string#string  结果
-- @see string.rtrim, string.trim

--[[--

去除输入字符串头部的空白字符,返回结果

~~~ lua

local input = "  ABC"
print(string.ltrim(input))
-- 输出 ABC,输入字符串前面的两个空格被去掉了

~~~

空白字符包括:

-   空格
-   制表符 \t
-   换行符 \n
-   回到行首符 \r

]]

-- end --

function string.ltrim(input)
    return string.gsub(input, "^[ \t\n\r]+", "")
end

-- start --

--------------------------------
-- 去除输入字符串尾部的空白字符,返回结果
-- @function [parent=#string] rtrim
-- @param string input 输入字符串
-- @return string#string  结果
-- @see string.ltrim, string.trim

--[[--

去除输入字符串尾部的空白字符,返回结果

~~~ lua

local input = "ABC  "
print(string.rtrim(input))
-- 输出 ABC,输入字符串最后的两个空格被去掉了

~~~

]]

-- end --

function string.rtrim(input)
    return string.gsub(input, "[ \t\n\r]+$", "")
end

-- start --

--------------------------------
-- 去掉字符串首尾的空白字符,返回结果
-- @function [parent=#string] trim
-- @param string input 输入字符串
-- @return string#string  结果
-- @see string.ltrim, string.rtrim

--[[--

去掉字符串首尾的空白字符,返回结果

]]

-- end --

function string.trim(input)
    input = string.gsub(input, "^[ \t\n\r]+", "")
    return string.gsub(input, "[ \t\n\r]+$", "")
end

-- start --

--------------------------------
-- 将字符串的第一个字符转为大写,返回结果
-- @function [parent=#string] ucfirst
-- @param string input 输入字符串
-- @return string#string  结果

--[[--

将字符串的第一个字符转为大写,返回结果

~~~ lua

local input = "hello"
print(string.ucfirst(input))
-- 输出 Hello

~~~

]]

-- end --

function string.ucfirst(input)
    return string.upper(string.sub(input, 1, 1)) .. string.sub(input, 2)
end

local function urlencodechar(char)
    return "%" .. string.format("%02X", string.byte(char))
end

-- start --

--------------------------------
-- 将字符串转换为符合 URL 传递要求的格式,并返回转换结果
-- @function [parent=#string] urlencode
-- @param string input 输入字符串
-- @return string#string  转换后的结果
-- @see string.urldecode

--[[--

将字符串转换为符合 URL 传递要求的格式,并返回转换结果

~~~ lua

local input = "hello world"
print(string.urlencode(input))
-- 输出
-- hello%20world

~~~

]]

-- end --

function string.urlencode(input)
    -- convert line endings
    input = string.gsub(tostring(input), "\n", "\r\n")
    -- escape all characters but alphanumeric, '.' and '-'
    input = string.gsub(input, "([^%w%.%- ])", urlencodechar)
    -- convert spaces to "+" symbols
    return string.gsub(input, " ", "+")
end

-- start --

--------------------------------
-- 将 URL 中的特殊字符还原,并返回结果
-- @function [parent=#string] urldecode
-- @param string input 输入字符串
-- @return string#string  转换后的结果
-- @see string.urlencode

--[[--

将 URL 中的特殊字符还原,并返回结果

~~~ lua

local input = "hello%20world"
print(string.urldecode(input))
-- 输出
-- hello world

~~~

]]

-- end --

function string.urldecode(input)
    input = string.gsub (input, "+", " ")
    input = string.gsub (input, "%%(%x%x)", function(h) return string.char(checknumber(h,16)) end)
    input = string.gsub (input, "\r\n", "\n")
    return input
end

-- start --

--------------------------------
-- 计算 UTF8 字符串的长度,每一个中文算一个字符
-- @function [parent=#string] utf8len
-- @param string input 输入字符串
-- @return integer#integer  长度

--[[--

计算 UTF8 字符串的长度,每一个中文算一个字符

~~~ lua

local input = "你好World"
print(string.utf8len(input))
-- 输出 7

~~~

]]

-- end --

function string.utf8len(input)
    local len  = string.len(input)
    local left = len
    local cnt  = 0
    local arr  = {0, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc}
    while left ~= 0 do
        local tmp = string.byte(input, -left)
        local i   = #arr
        while arr[i] do
            if tmp >= arr[i] then
                left = left - i
                break
            end
            i = i - 1
        end
        cnt = cnt + 1
    end
    return cnt
end

-- start --

--------------------------------
-- 将数值格式化为包含千分位分隔符的字符串
-- @function [parent=#string] formatnumberthousands
-- @param number num 数值
-- @return string#string  格式化结果

--[[--

将数值格式化为包含千分位分隔符的字符串

~~~ lua

print(string.formatnumberthousands(1924235))
-- 输出 1,924,235

~~~

]]

-- end --

function string.formatnumberthousands(num)
    local formatted = tostring(checknumber(num))
    local k
    while true do
        formatted, k = string.gsub(formatted, "^(-?%d+)(%d%d%d)", '%1,%2')
        if k == 0 then break end
    end
    return formatted
end

-- start --

--------------------------------
-- 判断字符串a是否有前缀b
-- @function [parent=#string] hasPrefix
-- @param string s 源字符串
-- @param string prefix 前缀字符串
-- @return string#boolean  是否

--[[--

~~~ lua

print(string.hasPrefix("btn_return","btn_"))
-- 输出 true

~~~

]]

-- end --
function string.hasPrefix(s, prefix)
    if(s == nil or prefix == nil) then return false end
    local index = string.find(s, prefix)
    if(index == 1) then return true end
    return false
end

-- start --

--------------------------------
-- 判断字符串a是否有后缀b
-- @function [parent=#string] hasSuffix
-- @param string s 源字符串
-- @param string suffix 后缀字符串
-- @return string#boolean  是否

--[[--

~~~ lua

print(string.hasSuffix(“bj.png”,".png"))
-- 输出 true

~~~

]]
-- end --

function string.GetShortName(str,maxLen)
    -- print(str,"===GetShortNameGetShortName===")
    maxLen = maxLen or 4
    local charNum = sting.getStringCharCount(str)
    if charNum > maxLen then
        local byteSize = 0
        local index = 1
        for i = 1 , maxLen do
            local byteCount = 0
            local curByte = string.byte(str, index)
            --print(curByte,"===curBytecurBytecurBytecurByte===" .. maxLen .. "     " ..charNum)
            if curByte > 0 and curByte < 128 then        
                byteCount = 1                        --1字节字符
            elseif curByte >= 192 and curByte < 224 then
                byteCount = 2                        --双字节字符
            elseif curByte >= 224 and curByte < 240 then
                byteCount = 3                        --汉字
            elseif curByte >= 240 and curByte < 248 then
                byteCount = 4                        --4字节字符
            end
            byteSize = byteSize + byteCount
            index = index + byteCount                -- 重置下一字节的索引
        end
        return string.sub(str,1,byteSize)..'..'
    else
        return str
    end
end

--计算字符串字符个数
function string.getStringCharCount(str)
    local lenInByte = #str
    -- print("--getStringCharCount--",lenInByte)
    local charCount = 0
    local i = 1
    while (i <= lenInByte) 
    do
        local curByte = string.byte(str, i)
        -- print("curBytecurByte==",curByte)
        local byteCount = 1
        if curByte > 0 and curByte < 128 then        
            byteCount = 1                        --1字节字符
        elseif curByte >= 192 and curByte < 224 then
            byteCount = 2                        --双字节字符
        elseif curByte >= 224 and curByte < 240 then
            byteCount = 3                        --汉字
        elseif curByte >= 240 and curByte < 248 then
            byteCount = 4                        --4字节字符
        end
        
        local char = string.sub(str, i, i + byteCount - 1)
        i = i + byteCount                                  -- 重置下一字节的索引
        charCount = charCount + 1                          -- 字符的个数(长度)
    end
    return charCount
end


function string.hasSuffix(s, suffix)
    if(s == nil or suffix == nil) then return false end
    local pos = string.len(s) - string.len(suffix)
    return string.sub(s,pos + 1) == suffix
end

 

 
已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 技术黑板 设计师:CSDN官方博客 返回首页