(转载)lua的字符串及字符串格式化((Reprint) Lua’s string and string formatting)

原文链接

字符串的表示

  • “”
  • [[]]
  • 被以上三项框起来的内容即为string, 当选用其上的任意一种方式来表示字符串的时候,如果要字符串中包含它本身的符号,则需要转义。
    举个例子: print(“‘I love Crane_Moker'”) 输出:‘I love Crane_Mocker’而 print(“”lua is a nice language””) 则会报错print(“\”single dog\””) 输出”single dog”
    string.format()
    这个函数类似于lua他妈妈,c语言中的printf(),提供了格式化的选择举个例子: print(string.format(“Happy %d”, 1024)) 输出:Happy 1024注意,这里字符串”Happy 1024″是执行了函数string.format()的返回值,要想在终端显示它,还需要print()

    参数解释

    %c
    接受一个数字, 并将其转化为ASCII码表中对应的字符

    %d, %i
    接受一个数字并将其转化为有符号的整数格式

    %o
    接受一个数字并将其转化为八进制数格式

    %u
    接受一个数字并将其转化为无符号整数格式

    %x
    接受一个数字并将其转化为十六进制数格式, 使用小写字母

    %X
    接受一个数字并将其转化为十六进制数格式, 使用大写字母

    %e
    接受一个数字并将其转化为科学记数法格式, 使用小写字母e

    %E
    接受一个数字并将其转化为科学记数法格式, 使用大写字母E

    %f
    接受一个数字并将其转化为浮点数格式

    %g(%G)
    接受一个数字并将其转化为%e(%E, 对应%G)及%f中较短的一种格式

    %q
    接受一个字符串并将其转化为可安全被Lua编译器读入的格式

    %s
    接受一个字符串并按照给定的参数格式化该字符串

    这里还有在%之后以控制格式的参数

    参数解释不带该参数的默认情况

    +
    其后的数字转义符将让正数显示正号
    只有负数显示符号

    0
    指定了字串宽度时用0占位
    空格占位


    左对齐
    右对齐

    (m).(n)
    m字串裁切位数,n小数保留位数
     

    匹配模式
    string.gmatch(str, pattern)和string.match(str, pattern, init)
    string.gmatch()有迭代器,可以匹配目标str中的所有符合pattern要求的部分(在for循环之类的里面使用这个会是不错的选择)。而string.match()则只能匹配第一个,init决定了开始匹配的位置,默认是1(不要忘记了,在lua的table中默认以1开始哦)
    匹配的pattern ?

    参数匹配

    .(点)
    与任何字符配对

    %a
    与任何字母配对

    %c
    与任何控制符配对(例如\n)

    %d
    与任何数字配对

    %l
    与任何小写字母配对

    %p
    与任何标点(punctuation)配对

    %s
    与空白字符配对

    %u
    与任何大写字母配对

    %w
    与任何字母/数字配对

    %x
    与任何十六进制数配对

    %z
    与任何代表0的字符配对

    %x(此处x是非字母非数字字符)
    与字符x配对. 主要用来处理表达式中有功能的字符(^$()%.[]*±?)的配对问题, 例如%%与%配对

    [数个字符类]
    与任何[]中包含的字符类配对. 例如[%w_]与任何字母/数字, 或下划线符号(_)配对

    [^数个字符类]
    与任何不包含在[]中的字符类配对. 例如[^%s]与任何非空白字符配对

    lua中特殊字符有( ) . % + – * ? [ ^ $, 所以匹配是就需要%来转义,即上表中的%x
    模式条目

    符号涵义

    *
    将匹配零或多个该类的字符。 这个条目总是匹配尽可能长的串

    +
    将匹配一或更多个该类的字符。 这个条目总是匹配尽可能长的串


    将匹配零或更多个该类的字符。 和 ‘*’ 不同, 这个条目总是匹配尽可能短的串

    ?
    将匹配零或一个该类的字符。 只要有可能,它会匹配一个

    %n
    这里的 n 可以从 1 到 9; 这个条目匹配一个等于 n 号捕获物(后面有描述)的子串。

    %bxy
    这里的 x 和 y 是两个明确的字符; 这个条目匹配以 x 开始 y 结束, 且其中 x 和 y 保持 平衡 的字符串。 意思是,如果从左到右读这个字符串,对每次读到一个 x 就 +1 ,读到一个 y 就 -1, 最终结束处的那个 y 是第一个记数到 0 的 y。 举个例子,条目 %b() 可以匹配到括号平衡的表达式。

    %f[set]
    指 边境模式; 这个条目会匹配到一个位于 set 内某个字符之前的一个空串, 且这个位置的前一个字符不属于 set 。 集合 set 的含义如前面所述。 匹配出的那个空串之开始和结束点的计算就看成该处有个字符 ‘\0’ 一样。

    上面这个表是什么意思呢?不妨让我用*和+为大家举个例子:
    print(string.match(“Hello 1024”, “%d”)) 我们知道,string.match只匹配匹配到的第一个,所以这里可以匹配到符合pattern的部分,也就是在该字符串中的第一个数字1,所以输出为 1
    print(string.match(“Hello 1024”, “%d+”)) , 加号使条目尽可能长,所以这里输出为1024
    print(string.match(“Hello 1024”, “%d*”)), 由于*可以匹配到0个或多个该类字符,在这个字符串里,当然是先遇到了H,所以这里没有输出
    而print(string.match(“1024Hello”, “%d*”)), 就可以愉快输出1024啦
    顺嘴一提 string.char(arg) 和 string.byte(arg[,int])
    string.char()有一个或多个参数,顾名思义,是将数字转化为字符,当然,它可以将它们连起来,成为str
    string.byte()则将字符串的第指定(init)个字符返回对应的ascii码,默认是第一个

string.format()

参数 解释
%c 接受一个数字, 并将其转化为ASCII码表中对应的字符
%d, %i 接受一个数字并将其转化为有符号的整数格式
%o 接受一个数字并将其转化为八进制数格式
%u 接受一个数字并将其转化为无符号整数格式
%x 接受一个数字并将其转化为十六进制数格式, 使用小写字母
%X 接受一个数字并将其转化为十六进制数格式, 使用大写字母
%e 接受一个数字并将其转化为科学记数法格式, 使用小写字母e
%E 接受一个数字并将其转化为科学记数法格式, 使用大写字母E
%f 接受一个数字并将其转化为浮点数格式
%g(%G) 接受一个数字并将其转化为%e(%E, 对应%G)及%f中较短的一种格式
%q 接受一个字符串并将其转化为可安全被Lua编译器读入的格式
%s 接受一个字符串并按照给定的参数格式化该字符串
参数 解释 不带该参数的默认情况
+ 其后的数字转义符将让正数显示正号 只有负数显示符号
0 指定了字串宽度时用0占位 空格占位
左对齐 右对齐
(m).(n) m字串裁切位数,n小数保留位数  

匹配模式

string.gmatch(str, pattern)和string.match(str, pattern, init)

匹配的pattern ?

参数 匹配
.(点) 与任何字符配对
%a 与任何字母配对
%c 与任何控制符配对(例如\n)
%d 与任何数字配对
%l 与任何小写字母配对
%p 与任何标点(punctuation)配对
%s 与空白字符配对
%u 与任何大写字母配对
%w 与任何字母/数字配对
%x 与任何十六进制数配对
%z 与任何代表0的字符配对
%x(此处x是非字母非数字字符) 与字符x配对. 主要用来处理表达式中有功能的字符(^$()%.[]*±?)的配对问题, 例如%%与%配对
[数个字符类] 与任何[]中包含的字符类配对. 例如[%w_]与任何字母/数字, 或下划线符号(_)配对
[^数个字符类] 与任何不包含在[]中的字符类配对. 例如[^%s]与任何非空白字符配对
符号 涵义
* 将匹配零或多个该类的字符。 这个条目总是匹配尽可能长的串
+ 将匹配一或更多个该类的字符。 这个条目总是匹配尽可能长的串
将匹配零或更多个该类的字符。 和 ‘*’ 不同, 这个条目总是匹配尽可能短的串
? 将匹配零或一个该类的字符。 只要有可能,它会匹配一个
%n 这里的 n 可以从 1 到 9; 这个条目匹配一个等于 n 号捕获物(后面有描述)的子串。
%bxy 这里的 x 和 y 是两个明确的字符; 这个条目匹配以 x 开始 y 结束, 且其中 x 和 y 保持 平衡 的字符串。 意思是,如果从左到右读这个字符串,对每次读到一个 x 就 +1 ,读到一个 y 就 -1, 最终结束处的那个 y 是第一个记数到 0 的 y。 举个例子,条目 %b() 可以匹配到括号平衡的表达式。
%f[set] 指 边境模式; 这个条目会匹配到一个位于 set 内某个字符之前的一个空串, 且这个位置的前一个字符不属于 set 。 集合 set 的含义如前面所述。 匹配出的那个空串之开始和结束点的计算就看成该处有个字符 ‘\0’ 一样。

顺嘴一提 string.char(arg) 和 string.byte(arg[,int])

————————

Original link

Representation of string

  • “”
  • [[]]
  • The content boxed by the above three items is string. When you choose any way to represent the string, if you want the string to contain its own symbols, you need to escape.
    For example: Print (‘I love crane_moker ‘) output:’ I love crane ‘_ Mocker ‘and print (“” Lua is a nice language “”) will report an error. Print (“\” single dog \ “”) will output “single dog”
    string. format()
    This function is similar to Lua’s mother. Printf() in C language provides the option of formatting. For example, print (string.format (“happy%d”, 1024)) output: Happy 1024. Note that the string “happy 1024” here executes the function string The return value of format () needs print () to display it on the terminal
    Parameter interpretation
    %c
    Accept a number and convert it to the corresponding character in the ASCII code table
    %d, %i
    Accepts a number and converts it to signed integer format
    %o
    Accepts a number and converts it to octal format
    %u
    Accepts a number and converts it to unsigned integer format
    %x
    Accept a number and convert it to hexadecimal number format, using lowercase letters
    %X
    Accept a number and convert it to hexadecimal format, using uppercase letters
    %e
    Accept a number and convert it to scientific notation format, using the lowercase letter E
    %E
    Accept a number and convert it to scientific notation format, using the capital letter E
    %f
    Accepts a number and converts it to floating point format
    %g(%G)
    Accept a number and convert it to the shorter of% e (% e, corresponding to% g) and% F
    %q
    Accept a string and convert it to a format that can be safely read by the Lua compiler
    %s
    Accepts a string and formats it according to the given parameters
    There are also parameters after% to control the format
    Parameter explains the default without this parameter
    +
    The numeric escape character that follows will cause the positive number to display a positive sign
    Only negative numbers display symbols
    0
    Use 0 to occupy the space when the string width is specified
    Space occupation

    Align left
    Right align
    (m). (n)
    M string cutting digits, N decimal reserved digits
     
    Matching pattern
    string. Gmatch (STR, pattern) and string match(str, pattern, init)
    string. Gmatch () has an iterator that can match all the parts of the target STR that meet the pattern requirements (it would be a good choice to use this in for loops and the like). And string Match () can only match the first one. Init determines the starting position of matching, and the default is 1 (don’t forget that it starts with 1 by default in Lua’s table)
    Matching pattern?
    Parameter matching
    (point)
    Pair with any character
    %a
    Pair with any letter
    %c
    Pair with any control character (for example \ n)
    %d
    Pair with any number
    %l
    Pair with any lowercase letter
    %p
    Pair with any punctuation
    %s
    Pair with white space characters
    %u
    Pair with any capital letter
    %w
    Pair with any letter / number
    %x
    Pair with any hexadecimal number
    %z
    Pair with any character representing 0
    %X (where x is a non alphanumeric character)
    Pair with character X It is mainly used to process functional characters (^ $()%) in expressions []*±?) Pairing problems, such as pairing%% with%
    [several character classes]
    Pair with any character class contained in [] For example [% w_] With any letter / number, or underscore () pair
    [^ several character classes]
    Pair with any character class not contained in [] For example, [^% s] is paired with any non whitespace character
    Special characters in Lua are ().% + – *? [^ $, so% is needed to escape for matching, that is,% X in the above table
    Mode entry
    Symbolic meaning
    *
    Zero or more characters of this class will be matched. This entry always matches the longest possible string
    +
    Will match one or more characters of this class. This entry always matches the longest possible string

    Zero or more characters of this class will be matched. Unlike ‘*’, this entry always matches the shortest possible string
    ?
    Will match zero or one character of this class. Whenever possible, it will match one
    %n
    N can be from here to 9; This entry matches a substring equal to catch n (described later).
    %bxy
    Here X and y are two clear characters; This entry matches a string that starts with X and ends with y, where x and y are balanced. This means that if you read this string from left to right, for each time you read an X, it will be + 1, and when you read a Y, it will be – 1. The y at the end is the first y to count to 0. For example, entry% B () can match an expression with balanced parentheses.
    %f[set]
    Refers to the border mode; This entry will match an empty string before a character in set, and the previous character in this position does not belong to set. The meaning of set is described above. The start and end points of the matched empty string are calculated as if there were a character ‘\ 0’.
    What does the above table mean? Let me give you an example with * and +:
    Print (string. Match (“Hello 1024”, “% d”)) we know that string The first matching part of the pattern can only match 1 to 1, so the first matching part of the string can match
    Print (string. Match (“Hello 1024”, “% d +”)), the plus sign makes the entry as long as possible, so the output here is 1024
    Print (string. Match (“Hello 1024”, “% d *”)), since * can match 0 or more characters of this type, in this string, of course, h is encountered first, so there is no output here
    Print (string. Match (“1024hello”, “% d *”)) can output 1024 happily
    Mention string Char (ARG) and string byte(arg[,int])
    string. Char () has one or more parameters. As the name suggests, it converts numbers into characters. Of course, it can connect them into str
    string. Byte() returns the specified (init) character of the string to the corresponding ASCII code, which is the first character by default

string.format()

参数 解释
%c 接受一个数字, 并将其转化为ASCII码表中对应的字符
%d, %i 接受一个数字并将其转化为有符号的整数格式
%o 接受一个数字并将其转化为八进制数格式
%u 接受一个数字并将其转化为无符号整数格式
%x 接受一个数字并将其转化为十六进制数格式, 使用小写字母
%X 接受一个数字并将其转化为十六进制数格式, 使用大写字母
%e 接受一个数字并将其转化为科学记数法格式, 使用小写字母e
%E 接受一个数字并将其转化为科学记数法格式, 使用大写字母E
%f 接受一个数字并将其转化为浮点数格式
%g(%G) 接受一个数字并将其转化为%e(%E, 对应%G)及%f中较短的一种格式
%q 接受一个字符串并将其转化为可安全被Lua编译器读入的格式
%s 接受一个字符串并按照给定的参数格式化该字符串
参数 解释 不带该参数的默认情况
+ 其后的数字转义符将让正数显示正号 只有负数显示符号
0 指定了字串宽度时用0占位 空格占位
左对齐 右对齐
(m).(n) m字串裁切位数,n小数保留位数  

Matching pattern

string.gmatch(str, pattern)和string.match(str, pattern, init)

匹配的pattern ?

参数 匹配
.(点) 与任何字符配对
%a 与任何字母配对
%c 与任何控制符配对(例如\n)
%d 与任何数字配对
%l 与任何小写字母配对
%p 与任何标点(punctuation)配对
%s 与空白字符配对
%u 与任何大写字母配对
%w 与任何字母/数字配对
%x 与任何十六进制数配对
%z 与任何代表0的字符配对
%x(此处x是非字母非数字字符) 与字符x配对. 主要用来处理表达式中有功能的字符(^$()%.[]*±?)的配对问题, 例如%%与%配对
[数个字符类] 与任何[]中包含的字符类配对. 例如[%w_]与任何字母/数字, 或下划线符号(_)配对
[^数个字符类] 与任何不包含在[]中的字符类配对. 例如[^%s]与任何非空白字符配对
符号 涵义
* 将匹配零或多个该类的字符。 这个条目总是匹配尽可能长的串
+ 将匹配一或更多个该类的字符。 这个条目总是匹配尽可能长的串
将匹配零或更多个该类的字符。 和 ‘*’ 不同, 这个条目总是匹配尽可能短的串
? 将匹配零或一个该类的字符。 只要有可能,它会匹配一个
%n 这里的 n 可以从 1 到 9; 这个条目匹配一个等于 n 号捕获物(后面有描述)的子串。
%bxy 这里的 x 和 y 是两个明确的字符; 这个条目匹配以 x 开始 y 结束, 且其中 x 和 y 保持 平衡 的字符串。 意思是,如果从左到右读这个字符串,对每次读到一个 x 就 +1 ,读到一个 y 就 -1, 最终结束处的那个 y 是第一个记数到 0 的 y。 举个例子,条目 %b() 可以匹配到括号平衡的表达式。
%f[set] 指 边境模式; 这个条目会匹配到一个位于 set 内某个字符之前的一个空串, 且这个位置的前一个字符不属于 set 。 集合 set 的含义如前面所述。 匹配出的那个空串之开始和结束点的计算就看成该处有个字符 ‘\0’ 一样。

顺嘴一提 string.char(arg) 和 string.byte(arg[,int])