Lua字符串及字符串匹配
2014-11-18 20:07
204 查看
--lua中字符串索引从前往后是1,2,……,从后往前是-1,-2……。
--string库中所有的function都不会直接操作字符串,只返回一个结果
捕获是这样一种机制:可以使用模式串的一部分匹配目标串的一部分。将你想捕获的模式用圆括号括起来,就指定了一个捕获。
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函数总是先返回匹配串的索引下标,然后返回子模式匹配的捕获部分。
--给数字添加上千分号
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
-- @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.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
--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.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
相关文章推荐
- Lua字符串及字符串匹配
- 不包含某字符串的字符串匹配 (正则表达式)
- lua中字符串匹配笔记
- 字符串面试题系列之四:字符串匹配
- Lua字符串匹配
- 程序员编程艺术第三十~三十一章:字符串转换成整数,通配符字符串匹配
- oracle不能直接用字符串匹配日期,字符串须转换为日期格式
- 字符串链接和字符串匹配
- 字符串转换成整数,通配符的字符串匹配(转)
- 字符串转换成整数,字符串匹配问题
- lua中字符串匹配笔记
- Lua中字符串匹配笔记
- 字符串---字符串匹配KMP算法
- 字符串---字符串匹配KMP算法
- 字符串转换成整数,通配符的字符串匹配问题
- Java 字符串匹配和替换字符串
- 算法实现字符串匹配问题:从三个字符串中找出共有的最长部分。
- 字符串匹配算法实现(两个字符串中含有的字符和个数都相同)
- 字符串匹配问题(int countABC(* s) 输入任何一串字符串,计算机其
- 假设两个字符串中所含有的字符和个数都相同我们就叫这两个字符串匹配, 比如:abcda和adabc,由于出现的字符个数都是相同,只是顺序不同, 所以这两个字符串是匹配的。要求高效!