目录:
  1. lua的string内置库
    1. byte
      1. char
        1. find
          1. match
            1. sub
              1. gmatch
                1. gsub
                  1. reverse
                    1. upper
                      1. lower
                        1. rep
                          1. len
                            1. format
                              1. 注意

                              lua的string内置库

                              阅读时间:全文 534 字,预估用时 3 分钟
                              创作日期:2022-04-13
                              文章标签:
                              上篇文章:lua的table内置库
                              下篇文章:lua基本语法
                               
                              BEGIN

                              byte

                              string.byte(s [, i [, j]]) s:byte([i [, j]])

                              返回字符串指定字符下标的ASCII码,i为起点下标(默认为1),j为终点下标,如:

                              > string.byte("ABCDE", 2, 5)
                              66	67	68	69
                              -- 返回的是BCDE的ASCII码,可通过结构赋值赋予其它变量

                              char

                              string.char(i1, i2, …)

                              将ASCII码转换为字符串

                              > string.char(66, 67, 68, 69)
                              BCDE

                              find

                              string.find(s, pattern [, index [, plain]]) s:find(pattern [, index [, plain]])

                              查找子字符串,返回查找到的起止下标,如果没有找到则返回nil,其中index入参传入数字表示搜索的起点,plain入参传入boolean值,默认为false表示正则模式,传入true则pattern为非正则匹配,如:

                              > string.find("ABCDE", 'AB')
                              1	2

                              match

                              string.match (s, pattern [, index]) s:match(pattern [, index])

                              查找符合正则匹配的子字符串,index入参传入数字表示搜索的起点,只会匹配一个

                              sub

                              string.sub(s, i [, j]) s:sub(i [,j])

                              裁剪并返回对应下标的字符串

                              gmatch

                              string.gmatch(s, pattern) s:gmatch(pattern)

                              与match的区别是可以匹配多个,并返回匹配到的迭代器

                              gsub

                              string.gsub(s, pattern, replace [, n]) s:gsub(pattern, replace [,n])

                              用于替换匹配到的值,并返回替换后的结果及执行替换的次数,其中入参replace可以为字符串或者函数,当为函数时返回的值就是要替换的值,入参n表示需要替换的次数,如:

                              > string.gsub("banana", "a", "A", 2)
                              bAnAna  2
                              > string.gsub("banana", "(a)(n)", function(a,b) return b..a end)
                              bnanaa	2

                              reverse

                              string.reverse(s) s:reverse()

                              返回反转后的字符串

                              upper

                              string.upper(s) s:upper()

                              返回字符串转大写结果

                              lower

                              string.lower(s) s:lower()

                              返回字符串转小写结果

                              rep

                              string.rep(s, n) s:rep(n)

                              返回字符串重复拼接n次后的结果,如:

                              > string.rep("Lua ",5)
                              Lua Lua Lua Lua Lua

                              len

                              string.len(s) s:len()

                              返回字符串长度

                              format

                              string.format(s, e1, e2, …) s:format(e1, e2, …)

                              用于格式化字符串

                              > string.format("%c %s %q %f %d", 76, "Hello", "Lua user!", math.pi, 100)
                              L Hello "Lua user!" 3.141593 100

                              其中格式占位符有:

                              占位符作用
                              %s字符串
                              %q带引号字符串
                              %cASCII码转字符
                              %d整数
                              %f浮点数
                              %o八进制
                              %x十六进制
                              %X十六进制(字符大写)

                              注意

                              1. 正则匹配中用-表示非贪婪匹配,如:
                              > = string.match("one |two| three |four| five", '|.*|')
                              |two| three |four|
                              > = string.match("one |two| three |four| five", '|.-|')
                              |two|
                              FINISH
                              上篇文章:lua的table内置库
                              下篇文章:lua基本语法

                              随机文章
                              人生倒计时
                              default