lua string方法拓展

--[[--
用指定字符或字符串分割输入字符串，返回包含分割结果的数组
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"}

@param string input 输入字符串
@param string delimiter 分割标记字符或字符串
@return array 包含分割结果的数组
]]
function string.split(input, delimiter)
    input = tostring(input)
    delimiter = tostring(delimiter)
    if (delimiter=='') then return false end
    local pos,arr = , {}for st,sp in function() return string.find(input, delimiter, pos, true) end do
        table.insert(arr, string.sub(input, pos, st - ))
        pos = sp +
    end
    table.insert(arr, string.sub(input, pos))
    return arr
end

--[[--
去除输入字符串头部的空白字符，返回结果
local input = "  ABC"
print(string.ltrim(input))
-- res ABC，输入字符串前面的两个空格被去掉了

空白字符包括：
-   空格
-   制表符 \t
-   换行符 \n
-   回到行首符 \r
@param string input 输入字符串
@return string 结果
@see string.rtrim, string.trim
]]
function string.ltrim(input)
    return string.gsub(input, "^[ \t\n\r]+", "")
end
--[[--
去除输入字符串尾部的空白字符，返回结果
local input = "ABC  "
print(string.ltrim(input))
-- res ABC，输入字符串最后的两个空格被去掉了

@param string input 输入字符串
@return string 结果
@see string.ltrim, string.trim

]]
function string.rtrim(input)
    return string.gsub(input, "[ \t\n\r]+$", "")
end
--[[--
去掉字符串首尾的空白字符，返回结果
@param string input 输入字符串
@return string 结果
@see string.ltrim, string.rtrim
]]
function string.trim(input)
    input = string.gsub(input, "^[ \t\n\r]+", "")
    return string.gsub(input, "[ \t\n\r]+$", "")
end

--[[--
将字符串的第一个字符转为大写，返回结果
local input = "hello"
print(string.ucfirst(input))
-- res Hello
@param string input 输入字符串
@return string 结果
]]
function string.ucfirst(input)
    return string.upper(string.sub(input, , )) .. string.sub(input, )
end--[[--
计算 UTF8 字符串的长度，每一个中文算一个字符
local input = "你好World"
print(string.utf8len(input))
-- res 7
@param string input 输入字符串
@return integer 长度
]]
function string.utf8len(input)
    local len  = string.len(input)
    local left = len
    local cnt  =
    local arr  = {, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc}
    while left ~=  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 -
        end
        cnt = cnt +
    end
    return cnt
end

----过滤出规范字符 只保留汉字、数字、字符
function string.filterSpecChars(s)
    local ss = {}
    local k =
    while true do
        if k > #s then break end
        local c = string.byte(s,k)
        if not c then break end
        if c< then
            if (c>= and c<=) or (c>=  and c<=) or (c>= and c<=) then
                table.insert(ss, string.char(c))
            end
            k = k +
        elseif c< then
            k = k +
        elseif c< then
            if c>= and c<= then
                local c1 = string.byte(s,k+)
                local c2 = string.byte(s,k+)
                if c1 and c2 then
                    local a1,a2,a3,a4 = ,,,
                    if c ==  then a1 =
                    elseif c ==  then
                        a2,a4 = ,c1 ~=  and  or
                    end
                    if c1>=a1 and c1<=a2 and c2>=a3 and c2<=a4 then
                        table.insert(ss, string.char(c,c1,c2))
                    end
                end
            end
            k = k +
        elseif c< then
            k = k +
        elseif c< then
            k = k +
        elseif c< then
            k = k +
        end
    end
    return table.concat(ss)
end

--[[--
将数值格式化为包含千分位分隔符的字符串
print(string.formatnumberthousands())
-- 输出 ,,

@param number num 数值
@return string 格式化结果
]]
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 ==  then break end
    end
    return formatted
end
-- 判断utf8字符byte长度
-- 0xxxxxxx -  byte
-- 110yxxxx - ,  byte
-- 1110yyyy - ,  byte
-- 11110zzz - ,  byte
local function chsize(char)
    if not char then
        print("not char")
        return
    elseif char >  then
        return
    elseif char >  then
        return
    elseif char >  then
        return
    else
        return
    end
end

-- 截取utf8 字符串
-- str:         要截取的字符串
-- startChar:   开始字符下标,从1开始
-- numChars:    要截取的字符长度
function string.utf8sub(str, startChar, numChars)
    local startIndex =
    while startChar >  do
        local char = string.byte(str, startIndex)
        startIndex = startIndex + chsize(char)
        startChar = startChar -
    end

    local currentIndex = startIndex

    while numChars >  and currentIndex <= #str do
        local char = string.byte(str, currentIndex)
        currentIndex = currentIndex + chsize(char)
        numChars = numChars -
    end
    return str:sub(startIndex, currentIndex - )
end

--判断字符串是否为nil或““
function string.IsNilOrEmpty(str)
    if not str or str == "" then
        return true
    end
    return false
end