Lua实现的常用string库

常用字符串操作函数，使用Lua实现

--[[
    命名空间: xstr
    作者: apache(email: [email protected]; website: http://hi.baidu.com/hqwfreefly)
    版本号: 0.2 (from 0.1)
    创建日期: 2010-10-17
    函数列表: trim, capitalize, count, startswith, endswith, expendtabs, isalnum, isalpha, isdigit, islower, isupper,
              join, lower, upper, partition, zfill, ljust, rjust, center, dir, help
    声明: 该软件为自由软件，遵循GPL协议。如果你需要为xstr增加函数，请在func_list中添加函数名，并在help函数中为其撰写帮助文档
    帮助: xstr:dir() 列出命名空间下的函数列表。xstr:help("func")查看func的帮助文档
    修改历史: 修改count函数的实现，使用gsub统计个数
--]]
xstr = {
    func_list = "trim, capitalize, count, startswith, endswith, expendtabs, isalnum, isalpha, isdigit, islower, isupper, join, lower, upper, partition, zfill, ljust, rjust, center, dir, help",
    --[[去除str中的所有空格。成功返回去除空格后的字符串，失败返回nil和失败信息]]
    trim = function (self, str)
        if str == nil then
            return nil, "the string parameter is nil"
        end
        str = string.gsub(str, " ", "")
        return str
    end,
    --[[将str的第一个字符转化为大写字符。成功返回转换后的字符串，失败返回nil和失败信息]]
    capitalize = function(self, str)
        if str == nil then
            return nil, "the string parameter is nil"
        end
        local ch = string.sub(str, 1, 1)
        local len = string.len(str)
        if ch < 'a' or ch > 'z' then
            return str
        end
        ch = string.char(string.byte(ch) - 32)
        if len == 1 then
            return ch
        else
            return ch .. string.sub(str, 2, len)
        end
    end,
    --[[统计str中substr出现的次数。from, to用于指定起始位置，缺省状态下from为1，to为字符串长度。成功返回统计个数，失败返回nil和失败信息]]
    count = function(self, str, substr, from, to)
        if str == nil or substr == nil then
            return nil, "the string or the sub-string parameter is nil"
        end
        from = from or 1
        if to == nil or to > string.len(str) then
            to = string.len(str)
        end
        local str_tmp = string.sub(str, from ,to)
        local n = 0
        _, n = string.gsub(str, substr, '')
        return n
    end,
    --[[判断str是否以substr开头。是返回true，否返回false，失败返回失败信息]]
    startswith = function(self, str, substr)
        if str == nil or substr == nil then
            return nil, "the string or the sub-stirng parameter is nil"
        end
        if string.find(str, substr) ~= 1 then
            return false
        else
            return true
        end
    end,
    --[[判断str是否以substr结尾。是返回true，否返回false，失败返回失败信息]]
    endswith = function(self, str, substr)
        if str == nil or substr == nil then
            return nil, "the string or the sub-string parameter is nil"
        end
        str_tmp = string.reverse(str)
        substr_tmp = string.reverse(substr)
        if string.find(str_tmp, substr_tmp) ~= 1 then
            return false
        else
            return true
        end
    end,
    --[[使用空格替换str中的制表符，默认空格个数为8。返回替换后的字符串]]
    expendtabs = function(self, str, n)
        if str == nil then
            return nil, "the string parameter is nil"
        end
        n = n or 8
        str = string.gsub(str, "\t", string.rep(" ", n))
        return str
    end,
    --[[如果str仅由字母或数字组成，则返回true，否则返回false。失败返回nil和失败信息]]
    isalnum = function(self, str)
        if str == nil then
            return nil, "the string parameter is nil"
        end
        local len = string.len(str)
        for i = 1, len do
            local ch = string.sub(str, i, i)
            if not ((ch >= 'a' and ch <= 'z') or (ch >= 'A' and ch <= 'Z') or (ch >= '0' and ch <= '9')) then
                return false
            end
        end
        return true
    end,
    --[[如果str全部由字母组成，则返回true，否则返回false。失败返回nil和失败信息]]
    isalpha = function(self, str)
        if str == nil then
            return nil, "the string parameter is nil"
        end
        local len = string.len(str)
        for i = 1, len do
            local ch = string.sub(str, i, i)
            if not ((ch >= 'a' and ch <= 'z') or (ch >= 'A' and ch <= 'Z')) then
                return false
            end
        end
        return true
    end,
    --[[如果str全部由数字组成，则返回true，否则返回false。失败返回nil和失败信息]]
    isdigit = function(self, str)
        if str == nil then
            return nil, "the string parameter is nil"
        end
        local len = string.len(str)
        for i = 1, len do
            local ch = string.sub(str, i, i)
            if ch < '0' or ch > '9' then
                return false
            end
        end
        return true
    end,
    --[[如果str全部由小写字母组成，则返回true，否则返回false。失败返回nil和失败信息]]
    islower = function(self, str)
        if str == nil then
            return nil, "the string parameter is nil"
        end
        local len = string.len(str)
        for i = 1, len do
            local ch = string.sub(str, i, i)
            if ch < 'a' or ch > 'z' then
                return false
            end
        end
        return true
    end,
    --[[如果str全部由大写字母组成，则返回true，否则返回false。失败返回nil和失败信息]]
    isupper = function(self, str)
        if str == nil then
            return nil, "the string parameter is nil"
        end
        local len = string.len(str)
        for i = 1, len do
            local ch = string.sub(str, i, i)
            if ch < 'A' or ch > 'Z' then
                return false
            end
        end
        return true
    end,
    --[[使用substr连接str中的每个字符，返回连接后的新串。失败返回nil和失败信息]]
    join = function(self, str, substr)
        if str == nil or substr == nil then
            return nil, "the string or the sub-string parameter is nil"
        end
        local xlen = string.len(str) - 1
        if xlen == 0 then
            return str
        end
        local str_tmp = ""
        for i = 1, xlen do
            str_tmp = str_tmp .. string.sub(str, i, i) .. substr
        end
        str_tmp = str_tmp .. string.sub(str, xlen + 1, xlen + 1)
        return str_tmp
    end,
    --[[将str中的小写字母替换成大写字母，返回替换后的新串。失败返回nil和失败信息]]
    lower = function(self, str)
        if str == nil then
            return nil, "the string parameter is nil"
        end
        local len = string.len(str)
        local str_tmp = ""
        for i = 1, len do
            local ch = string.sub(str, i, i)
            if ch >= 'A' and ch <= 'Z' then
                ch = string.char(string.byte(ch) + 32)
            end
            str_tmp = str_tmp .. ch
        end
        return str_tmp
    end,
    --[[将str中的大写字母替换成小写字母，返回替换后的新串。失败返回nil和失败信息]]
    upper = function(self, str)
        if str == nil then
            return nil, "the string parameter is nil"
        end
        local len = string.len(str)
        local str_tmp = ""
        for i = 1, len do
            local ch = string.sub(str, i, i)
            if ch >= 'a' and ch <= 'z' then
                ch = string.char(string.byte(ch) - 32)
            end
            str_tmp = str_tmp .. ch
        end
        return str_tmp
    end,
    --[[将str以substr（从左向右查找）为界限拆分为3部分，返回拆分后的字符串。如果str中无substr则返回str, '', ''。失败返回nil和失败信息]]
    partition = function(self, str, substr)
        if str == nil or substr == nil then
            return nil, "the string or the sub-string parameter is nil"
        end
        local len = string.len(str)
        start_idx, end_idx = string.find(str, substr)
        if start_idx == nil or end_idx == len then
            return str, '', ''
        end
        return string.sub(str, 1, start_idx - 1), string.sub(str, start_idx, end_idx), string.sub(str, end_idx + 1, len)
    end,
    --[[在str前面补0，使其总长度达到n。返回补充后的新串，如果str长度已经超过n，则直接返回str。失败返回nil和失败信息]]
    zfill = function(self, str, n)
        if str == nil then
            return nil, "the string parameter is nil"
        end
        if n == nil then
            return str
        end
        local format_str = "%0" .. n .. "s"
        return string.format(format_str, str)
    end,
    -----------------------------------------------------------------------------------------------------------------------------------------
    --[[设置str的位宽，默认的填充字符为空格。对齐方式为左对齐（rjust为右对齐，center为中间对齐）。返回设置后的字符串。失败返回nil和失败信息]]
    ljust = function(self, str, n, ch)
        if str == nil then
            return nil, "the string parameter is nil"
        end
        ch = ch or " "
        n = tonumber(n) or 0
        local len = string.len(str)
        return string.rep(ch, n - len) .. str
    end,
    rjust = function(self, str, n, ch)
        if str == nil then
            return nil, "the string parameter is nil"
        end
        ch = ch or " "
        n = tonumber(n) or 0
        local len = string.len(str)
        return str .. string.rep(ch, n - len)
    end,
    center = function(self, str, n, ch)
        if str == nil then
            return nil, "the string parameter is nil"
        end
        ch = ch or " "
        n = tonumber(n) or 0
        local len = string.len(str)
        rn_tmp = math.floor((n - len) / 2)
        ln_tmp = n - rn_tmp - len
        return string.rep(ch, rn_tmp) .. str .. string.rep(ch, ln_tmp)
    end,
    ------------------------------------------------------------------------------------------------------------------------------------------
    --[[显示xstr命名空间的所有函数名]]
    dir = function(self)
        print(self.func_list)
    end,
    --[[打印指定函数的帮助信息, 打印成功返回true，否则返回false]]
    help = function(self, fun_name)
        man = {
            ["trim"] = "xstr:trim(str) --> string | nil, err_msg\n  去除str中的所有空格，返回新串\n  print(xstr:trim(\"  hello wor ld \") --> helloworld",
            ["capitalize"] = "xstr:capitalize(str) --> string | nil, err_msg\n  将str的首字母大写，返回新串\n  print(xstr:capitalize(\"hello\") --> Hello",
            ["count"] = "xstr:count(str, substr [, from] [, to]) --> number | nil, err_msg\n  返回str中substr的个数, from和to用于指定统计范围, 缺省状态下为整个字符串\n  print(xstr:count(\"hello world!\", \"l\")) --> 3",
            ["startswith"] = "xstr:startswith(str, substr) --> boolean | nil, err_msg\n  判断str是否以substr开头, 是返回true，否返回false\n  print(xstr:startswith(\"hello world\", \"he\") --> true",
            ["endswith"] = "xstr:endswith(str, substr) --> boolean | nil, err_msg\n  判断str是否以substr结尾, 是返回true, 否返回false\n  print(xstr:endswith(\"hello world\", \"d\")) --> true",
            ["expendtabs"] = "xstr:expendtabs(str, n) --> string | nil, err_msg\n  将str中的Tab制表符替换为n格空格，返回新串。n默认为8\n  print(xstr:expendtabs(\"hello  world\")) --> hello        world",
            ["isalnum"] = "xstr:isalnum(str) --> boolean | nil, err_msg\n  判断str是否仅由字母和数字组成，是返回true，否返回false\n  print(xstr:isalnum(\"hello world:) 123\")) --> false",
            ["isalpha"] = "xstr:isalpha(str) --> boolean | nil, err_msg\n  判断str是否仅由字母组成，是返回true，否返回false\n  print(xstr:isalpha(\"hello WORLD\")) --> true",
            ["isdigit"] = "xstr:isdigit(str) --> boolean | nil, err_msg\n  判断str是否仅由数字组成，是返回true，否返回false\n  print(xstr:isdigit(\"0123456789\")) --> true",
            ["islower"] = "xstr:islower(str) --> boolean | nil, err_msg\n  判断str是否全部由小写字母组成，是返回true，否返回false\n  print(xstr:islower(\"hello world\")) --> true",
            ["isupper"] = "xstr:isupper(str) --> boolean | nil, err_msg\n  判断str是否全部由大写字母组成，是返回true，否返回false\n  print(xstr:isupper(\"HELLO WORLD\")) --> true",
            ["join"] = "xstr:join(str, substr) --> string | nil, err_msg\n  使用substr连接str中的每个元素，返回新串\n  print(xstr:join(\"hello\", \"--\")) --> h--e--l--l--o",
            ["lower"] = "xstr:lower(str) --> string | nil, err_msg\n  将str中的大写字母小写化，返回新串\n  print(xstr:lower(\"HeLLo WORld 2010\")) --> hello wold 2010",
            ["upper"] = "xstr:upper(str) --> string | nil, err_msg\n  将str中的小写字母大写化，返回新串\n  print(xstr:upper(\"hello world 2010\")) --> HELLO WORLD 2010",
            ["partition"] = "xstr:partition(str, substr) --> string, string, string | nil, err_msg\n  将str按照substr为界限拆分为3部分，返回拆分后的字符串\n  print(xstr:partition(\"hello*world\", \"wo\")) --> hello*  wo  rld",
            ["zfill"] = "xstr:zfill(str, n) --> string | nil, err_msg\n  在str前补0，使其总长度为n。返回新串\n  print(xstr:zfill(\"100\", 5)) --> 00100",
            ["ljust"] = "xstr:ljust(str, n, ch) --> string | nil, err_msg\n  按左对齐方式，使用ch补充str，使其位宽为n。ch默认为空格，n默认为0\n  print(xstr:ljust(\"hello\", 10, \"*\")) --> *****hello"